Open platform to collect and prioritize feedback
feature: S3, SQL and File System as blob storage (#681)
Guilherme Oenninga8c2eafab4bd
diff --git a/.circleci/config.yml b/.circleci/config.ymlindex 2edd1488d..b9898d32a 100644--- a/.circleci/config.yml+++ b/.circleci/config.yml@@ -46,6 +46,11 @@ jobs:docker:- image: *builder- image: postgres:9.6.8+ - image: minio/minio:RELEASE.2018-12-06T01-27-43Z+ command: server /data+ environment:+ MINIO_ACCESS_KEY: s3user+ MINIO_SECRET_KEY: s3user-s3cr3tworking_directory: *workdirsteps:- checkoutdiff --git a/.test.env b/.test.envindex 05d29f4d8..5b8aa2733 100644--- a/.test.env+++ b/.test.env@@ -5,6 +5,12 @@ DATABASE_URL=postgres://fider_test:fider_test_pw@localhost:5566/fider_test?sslmoHOST_DOMAIN=test.fider.ioJWT_SECRET=SOME_RANDOM_TOKEN_JUST_FOR_TESTING+S3_ENDPOINT_URL=http://localhost:9000+S3_REGION=us-east-1+S3_ACCESS_KEY_ID=s3user+S3_SECRET_ACCESS_KEY=s3user-s3cr3t+S3_BUCKET=test-bucket+CDN_HOST=OAUTH_FACEBOOK_APPID=FB_CL_IDdiff --git a/Gopkg.lock b/Gopkg.lockindex 0fb3d6cc2..f12942eaa 100644--- a/Gopkg.lock+++ b/Gopkg.lock@@ -9,6 +9,49 @@revision = "5a9e19d4e1e41a734154e44a2132b358afb49a03"version = "v0.13.0"+[[projects]]+ digest = "1:4488d53934d19e169589db4c90a11bf452fa1e5e97176fe60892ebf8121fe05a"+ name = "github.com/aws/aws-sdk-go"+ packages = [+ "aws",+ "aws/awserr",+ "aws/awsutil",+ "aws/client",+ "aws/client/metadata",+ "aws/corehandlers",+ "aws/credentials",+ "aws/credentials/ec2rolecreds",+ "aws/credentials/endpointcreds",+ "aws/credentials/processcreds",+ "aws/credentials/stscreds",+ "aws/csm",+ "aws/defaults",+ "aws/ec2metadata",+ "aws/endpoints",+ "aws/request",+ "aws/session",+ "aws/signer/v4",+ "internal/ini",+ "internal/s3err",+ "internal/sdkio",+ "internal/sdkrand",+ "internal/sdkuri",+ "internal/shareddefaults",+ "private/protocol",+ "private/protocol/eventstream",+ "private/protocol/eventstream/eventstreamapi",+ "private/protocol/query",+ "private/protocol/query/queryutil",+ "private/protocol/rest",+ "private/protocol/restxml",+ "private/protocol/xml/xmlutil",+ "service/s3",+ "service/sts",+ ]+ pruneopts = "UT"+ revision = "818fa5c274d4dee665096411e2bad037f47c31f7"+ version = "v1.16.3"+[[projects]]digest = "1:6098222470fe0172157ce9bbef5d2200df4edde17ee649c5d6e48330e4afa4c6"name = "github.com/dgrijalva/jwt-go"@@ -61,6 +104,13 @@revision = "e9f42fa127660e552d0ad2b589868d403a9be7c6"version = "v1.1.1"+[[projects]]+ digest = "1:bb81097a5b62634f3e9fec1014657855610c82d19b9a40c17612e32651e35dca"+ name = "github.com/jmespath/go-jmespath"+ packages = ["."]+ pruneopts = "UT"+ revision = "c2b33e84"+[[projects]]branch = "master"digest = "1:566c0d1d07fdc4f4707a8d5602004d6377be8a2b4f98a84a05cf328285208d32"@@ -170,6 +220,11 @@analyzer-name = "dep"analyzer-version = 1input-imports = [+ "github.com/aws/aws-sdk-go/aws",+ "github.com/aws/aws-sdk-go/aws/awserr",+ "github.com/aws/aws-sdk-go/aws/credentials",+ "github.com/aws/aws-sdk-go/aws/session",+ "github.com/aws/aws-sdk-go/service/s3","github.com/dgrijalva/jwt-go","github.com/goenning/letteravatar","github.com/goenning/sqlcertcache",diff --git a/Gopkg.toml b/Gopkg.tomlindex fae1a8a11..fef8e7863 100644--- a/Gopkg.toml+++ b/Gopkg.toml@@ -1,6 +1,18 @@ignored = ["github.com/magefile/mage/mg","github.com/magefile/mage/sh"]+[prune]+ [[prune.project]]+ name = "github.com/aws/aws-sdk-go"+ go-tests = true+ unused-packages = true++ [[prune.project]]+ name = "github.com/jmespath/go-jmespath"+ go-tests = true+ unused-packages = true+ non-go = false+[[constraint]]name = "github.com/dgrijalva/jwt-go"version = "^3.2.0"@@ -33,6 +45,10 @@ ignored = ["github.com/magefile/mage/mg","github.com/magefile/mage/sh"]branch = "master"name = "golang.org/x/crypto"+[[constraint]]+ version = "v1.16.3"+ name = "github.com/aws/aws-sdk-go"+[[constraint]]branch = "master"name = "github.com/goenning/sqlcertcache"diff --git a/app/pkg/blob/blob.go b/app/pkg/blob/blob.gonew file mode 100644index 000000000..07e248376--- /dev/null+++ b/app/pkg/blob/blob.go@@ -0,0 +1,45 @@+package blob++import (+ "errors"+ "strings"++ "github.com/getfider/fider/app/models"+)++// Blob is a file persisted somewhere+type Blob struct {+ Key string+ Object []byte+ Size int64+ ContentType string+}++// ErrNotFound is returned when given blob is not found+var ErrNotFound = errors.New("Blob not found")++// ErrInvalidKeyFormat is returned when blob key is in invalid format+var ErrInvalidKeyFormat = errors.New("Blob key is in invalid format")++// ValidateKey checks if key is is valid format+func ValidateKey(key string) error {+ if len(key) == 0 || len(key) > 512 || strings.Contains(key, " ") {+ return ErrInvalidKeyFormat+ }+ if strings.HasPrefix(key, "/") || strings.HasSuffix(key, "/") {+ return ErrInvalidKeyFormat+ }+ return nil+}++// Storage is how Fider persists blobs+type Storage interface {+ NewSession(tenant *models.Tenant) Session+}++// Session is a per-request object to interact with the storage+type Session interface {+ Get(key string) (*Blob, error)+ Delete(key string) error+ Store(b *Blob) error+}diff --git a/app/pkg/blob/blob_test.go b/app/pkg/blob/blob_test.gonew file mode 100644index 000000000..bbfa2d5c3--- /dev/null+++ b/app/pkg/blob/blob_test.go@@ -0,0 +1,296 @@+package blob_test++import (+ "io/ioutil"+ "os"+ "strings"+ "testing"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/session"+ awss3 "github.com/aws/aws-sdk-go/service/s3"+ "github.com/getfider/fider/app/pkg/errors"++ "github.com/getfider/fider/app/pkg/rand"++ "github.com/getfider/fider/app/pkg/dbx"++ "github.com/getfider/fider/app/models"++ "github.com/getfider/fider/app/pkg/blob/fs"+ "github.com/getfider/fider/app/pkg/blob/s3"+ "github.com/getfider/fider/app/pkg/blob/sql"++ . "github.com/getfider/fider/app/pkg/assert"+ "github.com/getfider/fider/app/pkg/blob"+ "github.com/getfider/fider/app/pkg/env"+)++var tenant1 = &models.Tenant{ID: 1}+var tenant2 = &models.Tenant{ID: 2}++func setupS3(t *testing.T) *s3.Storage {+ RegisterT(t)++ endpointURL := env.GetEnvOrDefault("S3_ENDPOINT_URL", "")+ region := env.GetEnvOrDefault("S3_REGION", "")+ accessKeyID := env.GetEnvOrDefault("S3_ACCESS_KEY_ID", "")+ secretAccessKey := env.GetEnvOrDefault("S3_SECRET_ACCESS_KEY", "")+ bucket := env.GetEnvOrDefault("S3_BUCKET", "")++ s3Config := &aws.Config{+ Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),+ Endpoint: aws.String(endpointURL),+ Region: aws.String(region),+ DisableSSL: aws.Bool(strings.HasSuffix(endpointURL, "http://")),+ S3ForcePathStyle: aws.Bool(true),+ }++ awsSession := session.New(s3Config)+ s3Client := awss3.New(awsSession)+ s3Client.DeleteBucket(&awss3.DeleteBucketInput{+ Bucket: aws.String(bucket),+ })+ s3Client.CreateBucket(&awss3.CreateBucketInput{+ Bucket: aws.String(bucket),+ })++ client, err := s3.NewStorage(endpointURL, region, accessKeyID, secretAccessKey, bucket)+ Expect(err).IsNil()++ return client+}++func setupSQL(t *testing.T) *sql.Storage {+ RegisterT(t)++ db := dbx.New()+ db.Seed()+ client, err := sql.NewStorage(db)+ Expect(err).IsNil()++ return client+}++func setupFS(t *testing.T) *fs.Storage {+ RegisterT(t)++ rootFolder := env.Path("tmp/fs_test")++ err := os.RemoveAll(rootFolder)+ Expect(err).IsNil()++ client, err := fs.NewStorage(rootFolder)+ Expect(err).IsNil()++ return client+}++type blobTestCase func(client blob.Storage, t *testing.T)+type setupFunction func(t *testing.T) blob.Storage++var tests = []struct {+ name string+ test blobTestCase+}{+ {"AllOperations", AllOperations},+ {"DeleteUnkownFile", DeleteUnkownFile},+ {"SameKey_DifferentTenant", SameKey_DifferentTenant},+ {"KeyFormats", KeyFormats},+}++func TestBlobStorage(t *testing.T) {+ for _, tt := range tests {+ t.Run("Test_FS_"+tt.name, func(t *testing.T) {+ client := setupFS(t)+ tt.test(client, t)+ })++ t.Run("Test_S3_"+tt.name, func(t *testing.T) {+ client := setupS3(t)+ tt.test(client, t)+ })++ t.Run("Test_SQL_"+tt.name, func(t *testing.T) {+ client := setupSQL(t)+ tt.test(client, t)+ })+ }+}++func AllOperations(client blob.Storage, t *testing.T) {+ sess := client.NewSession(nil)+ var testCases = []struct {+ localPath string+ key string+ contentType string+ }{+ {"/app/pkg/blob/testdata/file.txt", "some/path/to/file.txt", "text/plain; charset=utf-8"},+ {"/app/pkg/blob/testdata/file2.png", "file2.png", "image/png"},+ }++ for _, testCase := range testCases {+ bytes, _ := ioutil.ReadFile(env.Path(testCase.localPath))+ err := sess.Store(&blob.Blob{+ Key: testCase.key,+ Object: bytes,+ ContentType: testCase.contentType,+ Size: int64(len(bytes)),+ })+ Expect(err).IsNil()++ b, err := sess.Get(testCase.key)+ Expect(err).IsNil()+ Expect(b.Key).Equals(testCase.key)+ Expect(b.Object).Equals(bytes)+ Expect(b.Size).Equals(int64(len(bytes)))+ Expect(b.ContentType).Equals(testCase.contentType)++ err = sess.Delete(testCase.key)+ Expect(err).IsNil()++ b, err = sess.Get(testCase.key)+ Expect(b).IsNil()+ Expect(err).Equals(blob.ErrNotFound)+ }+}++func DeleteUnkownFile(client blob.Storage, t *testing.T) {+ sess := client.NewSession(nil)+ err := sess.Delete("path/somefile.txt")+ Expect(err).IsNil()+}++func SameKey_DifferentTenant(client blob.Storage, t *testing.T) {+ sess := client.NewSession(tenant1)+ key := "path/to/file3.txt"+ bytes, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file3.txt"))++ err := sess.Store(&blob.Blob{+ Key: key,+ Object: bytes,+ ContentType: "text/plain; charset=utf-8",+ Size: int64(len(bytes)),+ })+ Expect(err).IsNil()++ b, err := sess.Get(key)+ Expect(err).IsNil()+ Expect(b.Object).Equals(bytes)++ sess2 := client.NewSession(tenant2)++ b, err = sess2.Get(key)+ Expect(b).IsNil()+ Expect(err).Equals(blob.ErrNotFound)++ sess3 := client.NewSession(nil)++ b, err = sess3.Get(key)+ Expect(b).IsNil()+ Expect(err).Equals(blob.ErrNotFound)+}++func SameKey_DifferentTenant_Delete(client blob.Storage, t *testing.T) {+ key := "path/to/super-file.txt"+ bytes1, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file.txt"))+ bytes2, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file3.txt"))++ sess1 := client.NewSession(tenant1)+ sess2 := client.NewSession(tenant2)++ err := sess1.Store(&blob.Blob{+ Key: key,+ Object: bytes1,+ ContentType: "text/plain; charset=utf-8",+ Size: int64(len(bytes1)),+ })+ Expect(err).IsNil()++ err = sess2.Store(&blob.Blob{+ Key: key,+ Object: bytes2,+ ContentType: "text/plain; charset=utf-8",+ Size: int64(len(bytes2)),+ })+ Expect(err).IsNil()++ b, err := sess1.Get(key)+ Expect(err).IsNil()+ Expect(b.Object).Equals(len(bytes1))++ b, err = sess2.Get(key)+ Expect(err).IsNil()+ Expect(b.Object).Equals(len(bytes2))++ err = sess1.Delete(key)+ Expect(err).IsNil()++ b, err = sess2.Get(key)+ Expect(err).IsNil()+ Expect(b.Object).Equals(len(bytes2))+ Expect(err).IsNil()++ sess3 := client.NewSession(nil)+ b, err = sess3.Get(key)+ Expect(b).IsNil()+ Expect(err).Equals(blob.ErrNotFound)+}++func KeyFormats(client blob.Storage, t *testing.T) {+ RegisterT(t)+ sess := client.NewSession(nil)++ testCases := []struct {+ key string+ valid bool+ }{+ {+ key: "Jon",+ valid: true,+ },+ {+ key: "ASDHASJDKHAJSDJ.png",+ valid: true,+ },+ {+ key: "",+ valid: false,+ },+ {+ key: "/path/to/Jon",+ valid: false,+ },+ {+ key: "path/to/Jon/",+ valid: false,+ },+ {+ key: " file.txt",+ valid: false,+ },+ {+ key: "file with space.txt",+ valid: false,+ },+ {+ key: rand.String(513),+ valid: false,+ },+ }++ for _, testCase := range testCases {+ err := sess.Store(&blob.Blob{+ Key: testCase.key,+ Object: make([]byte, 0),+ ContentType: "text/plain; charset=utf-8",+ Size: 0,+ })+ if testCase.valid {+ Expect(err).IsNil()+ } else {+ Expect(errors.Cause(err)).Equals(blob.ErrInvalidKeyFormat)+ }+ }+}diff --git a/app/pkg/blob/fs/fs.go b/app/pkg/blob/fs/fs.gonew file mode 100644index 000000000..744e17392--- /dev/null+++ b/app/pkg/blob/fs/fs.go@@ -0,0 +1,112 @@+package fs++import (+ "io/ioutil"+ "net/http"+ "os"+ "path"+ "path/filepath"+ "strconv"++ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/blob"+ "github.com/getfider/fider/app/pkg/errors"+)++var perm os.FileMode = 0744++var _ blob.Storage = (*Storage)(nil)++// Storage stores blobs on FileSystem+type Storage struct {+ path string+}++// Session is a per-request object to interact with the storage+type Session struct {+ storage *Storage+ tenant *models.Tenant+}++// NewStorage creates a new FileSystem Storage+func NewStorage(path string) (*Storage, error) {+ err := os.MkdirAll(path, perm)+ if err != nil {+ return nil, errors.Wrap(err, "failed to create path '%s'", path)+ }++ return &Storage{+ path,+ }, nil+}++// NewSession creates a new session+func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {+ return &Session{+ storage: s,+ tenant: tenant,+ }+}++func (s *Session) keyFullPath(key string) string {+ fullPath := path.Join(s.storage.path, key)+ if s.tenant != nil {+ fullPath = path.Join("tenants", strconv.Itoa(s.tenant.ID), fullPath)+ }+ return fullPath+}++// Get returns a blob with given key+func (s *Session) Get(key string) (*blob.Blob, error) {+ fullPath := s.keyFullPath(key)+ stats, err := os.Stat(fullPath)+ if err != nil {+ if os.IsNotExist(err) {+ return nil, blob.ErrNotFound+ }+ return nil, errors.Wrap(err, "failed to get stats '%s' from FileSystem", key)+ }++ file, err := ioutil.ReadFile(fullPath)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get read '%s' from FileSystem", key)+ }++ return &blob.Blob{+ Key: key,+ Size: stats.Size(),+ ContentType: http.DetectContentType(file),+ Object: file,+ }, nil+}++// Delete a blob with given key+func (s *Session) Delete(key string) error {+ fullPath := s.keyFullPath(key)+ err := os.Remove(fullPath)+ if err != nil && !os.IsNotExist(err) {+ return errors.Wrap(err, "failed to delete file '%s' from FileSystem", key)+ }+ return nil+}++// Store a blob with given key and content. Blobs with same key are replaced.+func (s *Session) Store(b *blob.Blob) error {+ if err := blob.ValidateKey(b.Key); err != nil {+ return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)+ }++ fullPath := s.keyFullPath(b.Key)+ err := os.MkdirAll(filepath.Dir(fullPath), perm)++ if err != nil {+ return errors.Wrap(err, "failed to create folder '%s' on FileSystem", fullPath)+ }++ err = ioutil.WriteFile(fullPath, b.Object, perm)+ if err != nil {+ return errors.Wrap(err, "failed to create file '%s' on FileSystem", fullPath)+ }++ return nil+}diff --git a/app/pkg/blob/s3/s3.go b/app/pkg/blob/s3/s3.gonew file mode 100644index 000000000..0d7bf9535--- /dev/null+++ b/app/pkg/blob/s3/s3.go@@ -0,0 +1,134 @@+package s3++import (+ "bytes"+ "io/ioutil"+ "path"+ "strconv"+ "strings"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/session"+ "github.com/aws/aws-sdk-go/service/s3"+ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/blob"+ "github.com/getfider/fider/app/pkg/errors"+)++var _ blob.Storage = (*Storage)(nil)++// Storage stores blobs on an S3 compatible service+type Storage struct {+ s3Client *s3.S3+ bucket *string+}++// Session is a per-request object to interact with the storage+type Session struct {+ storage *Storage+ tenant *models.Tenant+}++func isNotFound(err error) bool {+ if awsErr, ok := err.(awserr.Error); ok {+ return awsErr.Code() == s3.ErrCodeNoSuchKey+ }+ return false+}++// NewStorage creates a S3 compatible service storage+func NewStorage(endpointURL, region, accessKeyID, secretAccessKey, bucket string) (*Storage, error) {++ s3Config := &aws.Config{+ Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),+ Endpoint: aws.String(endpointURL),+ Region: aws.String(region),+ DisableSSL: aws.Bool(strings.HasSuffix(endpointURL, "http://")),+ S3ForcePathStyle: aws.Bool(true),+ }+ awsSession := session.New(s3Config)++ return &Storage{+ s3Client: s3.New(awsSession),+ bucket: aws.String(bucket),+ }, nil+}++// NewSession creates a new session+func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {+ return &Session{+ storage: s,+ tenant: tenant,+ }+}++func (s *Session) keyFullPathURL(key string) string {+ if s.tenant != nil {+ return path.Join("tenants", strconv.Itoa(s.tenant.ID), key)+ }+ return key+}++// Get returns a blob with given key+func (s *Session) Get(key string) (*blob.Blob, error) {+ resp, err := s.storage.s3Client.GetObject(&s3.GetObjectInput{+ Bucket: s.storage.bucket,+ Key: aws.String(s.keyFullPathURL(key)),+ })+ if err != nil {+ if isNotFound(err) {+ return nil, blob.ErrNotFound+ }+ return nil, errors.Wrap(err, "failed to get blob '%s' from S3", key)+ }+ defer resp.Body.Close()++ bytes, err := ioutil.ReadAll(resp.Body)+ if err != nil {+ return nil, errors.Wrap(err, "failed to read blob body '%s' from S3", key)+ }++ return &blob.Blob{+ Key: key,+ Size: *resp.ContentLength,+ ContentType: *resp.ContentType,+ Object: bytes,+ }, nil+}++// Delete a blob with given key+func (s *Session) Delete(key string) error {+ _, err := s.storage.s3Client.DeleteObject(&s3.DeleteObjectInput{+ Bucket: s.storage.bucket,+ Key: aws.String(s.keyFullPathURL(key)),+ })+ if err != nil {+ if isNotFound(err) {+ return blob.ErrNotFound+ }+ return errors.Wrap(err, "failed to delete blob '%s' from S3", key)+ }+ return nil+}++// Store a blob with given key and content. Blobs with same key are replaced.+func (s *Session) Store(b *blob.Blob) error {+ if err := blob.ValidateKey(b.Key); err != nil {+ return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)+ }++ reader := bytes.NewReader(b.Object)+ _, err := s.storage.s3Client.PutObject(&s3.PutObjectInput{+ Bucket: s.storage.bucket,+ Key: aws.String(s.keyFullPathURL(b.Key)),+ ContentType: aws.String(b.ContentType),+ ACL: aws.String(s3.ObjectCannedACLPrivate),+ Body: reader,+ })+ if err != nil {+ return errors.Wrap(err, "failed to upload blob '%s' to S3", b.Key)+ }+ return nil+}diff --git a/app/pkg/blob/sql/sql.go b/app/pkg/blob/sql/sql.gonew file mode 100644index 000000000..3a83b8845--- /dev/null+++ b/app/pkg/blob/sql/sql.go@@ -0,0 +1,141 @@+package sql++import (+ "database/sql"+ "os"+ "time"++ "github.com/getfider/fider/app"++ "github.com/getfider/fider/app/models"+ "github.com/getfider/fider/app/pkg/blob"+ "github.com/getfider/fider/app/pkg/dbx"+ "github.com/getfider/fider/app/pkg/errors"+)++var perm os.FileMode = 0744++var _ blob.Storage = (*Storage)(nil)++type dbBlob struct {+ ContentType string `db:"content_type"`+ Size int64 `db:"size"`+ Content []byte `db:"file"`+}++// Storage stores blobs on FileSystem+type Storage struct {+ db *dbx.Database+}++// Session is a per-request object to interact with the storage+type Session struct {+ storage *Storage+ tenant *models.Tenant+}++// NewStorage creates a new FileSystem Storage+func NewStorage(db *dbx.Database) (*Storage, error) {+ return &Storage{+ db,+ }, nil+}++// NewSession creates a new session+func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {+ return &Session{+ storage: s,+ tenant: tenant,+ }+}++// Get returns a blob with given key+func (s *Session) Get(key string) (*blob.Blob, error) {+ trx, err := s.storage.db.Begin()+ if err != nil {+ return nil, errors.Wrap(err, "failed to open transaction")+ }+ defer trx.Commit()++ var tenantID sql.NullInt64+ if s.tenant != nil {+ tenantID.Scan(s.tenant.ID)+ }++ b := dbBlob{}+ err = trx.Get(&b, "SELECT file, content_type, size FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)+ if err != nil {+ if err == app.ErrNotFound {+ return nil, blob.ErrNotFound+ }+ return nil, errors.Wrap(err, "failed to get blob with key '%s'", key)+ }++ return &blob.Blob{+ Key: key,+ Size: b.Size,+ ContentType: b.ContentType,+ Object: b.Content,+ }, nil+}++// Delete a blob with given key+func (s *Session) Delete(key string) error {+ trx, err := s.storage.db.Begin()+ if err != nil {+ return errors.Wrap(err, "failed to open transaction")+ }++ var tenantID sql.NullInt64+ if s.tenant != nil {+ tenantID.Scan(s.tenant.ID)+ }++ _, err = trx.Execute("DELETE FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)+ if err != nil {+ return errors.Wrap(err, "failed to delete blob with key '%s'", key)+ }++ err = trx.Commit()+ if err != nil {+ defer trx.Rollback()+ return errors.Wrap(err, "failed to commit deletion of blob with key '%s'", key)+ }++ return nil+}++// Store a blob with given key and content. Blobs with same key are replaced.+func (s *Session) Store(b *blob.Blob) error {+ if err := blob.ValidateKey(b.Key); err != nil {+ return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)+ }++ trx, err := s.storage.db.Begin()+ if err != nil {+ return errors.Wrap(err, "failed to open transaction")+ }++ var tenantID sql.NullInt64+ if s.tenant != nil {+ tenantID.Scan(s.tenant.ID)+ }++ now := time.Now()+ _, err = trx.Execute(`+ INSERT INTO blobs (tenant_id, key, size, content_type, file, created_at, modified_at)+ VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (tenant_id, key)+ DO UPDATE SET size = $3, content_type = $4, file = $5, modified_at = $7+ `, tenantID, b.Key, b.Size, b.ContentType, b.Object, now, now)+ if err != nil {+ return errors.Wrap(err, "failed to store blob with key '%s'", b.Key)+ }++ err = trx.Commit()+ if err != nil {+ defer trx.Rollback()+ return errors.Wrap(err, "failed to commit store of blob with key '%s'", b.Key)+ }++ return nil+}diff --git a/app/pkg/blob/testdata/file.txt b/app/pkg/blob/testdata/file.txtnew file mode 100644index 000000000..56325056a--- /dev/null+++ b/app/pkg/blob/testdata/file.txt@@ -0,0 +1 @@+This is just a sample file!\ No newline at end of filediff --git a/app/pkg/blob/testdata/file2.png b/app/pkg/blob/testdata/file2.pngnew file mode 100644index 000000000..f704532eaBinary files /dev/null and b/app/pkg/blob/testdata/file2.png differdiff --git a/app/pkg/blob/testdata/file3.txt b/app/pkg/blob/testdata/file3.txtnew file mode 100644index 000000000..5e1c309da--- /dev/null+++ b/app/pkg/blob/testdata/file3.txt@@ -0,0 +1 @@+Hello World\ No newline at end of filediff --git a/app/pkg/dbx/setup.sql b/app/pkg/dbx/setup.sqlindex b033bd93d..ae7442253 100644--- a/app/pkg/dbx/setup.sql+++ b/app/pkg/dbx/setup.sql@@ -1,3 +1,4 @@+TRUNCATE TABLE blobs RESTART IDENTITY CASCADE;TRUNCATE TABLE logs RESTART IDENTITY CASCADE;TRUNCATE TABLE tenants RESTART IDENTITY CASCADE;diff --git a/docker-compose.yml b/docker-compose.ymlindex 74cd09d00..9a48e8058 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -19,4 +19,14 @@ services:- "5566:5432"environment:POSTGRES_USER: fider_test- POSTGRES_PASSWORD: fider_test_pw\ No newline at end of file+ POSTGRES_PASSWORD: fider_test_pw+ s3test:+ container_name: fider_s3test+ restart: always+ image: minio/minio:RELEASE.2018-12-06T01-27-43Z+ ports:+ - "9000:9000"+ environment:+ MINIO_ACCESS_KEY: s3user+ MINIO_SECRET_KEY: s3user-s3cr3t+ command: server /data\ No newline at end of filediff --git a/migrations/201812102208_create_blob_table.sql b/migrations/201812102208_create_blob_table.sqlnew file mode 100644index 000000000..756f51a10--- /dev/null+++ b/migrations/201812102208_create_blob_table.sql@@ -0,0 +1,13 @@+create table if not exists blobs (+ id serial not null,+ key varchar(512) not null,+ tenant_id int null,+ size bigint not null,+ content_type varchar(200) not null,+ file bytea not null,+ created_at timestamptz not null default now(),+ modified_at timestamptz not null default now(),+ primary key (id),+ unique (tenant_id, key),+ foreign key (tenant_id) references tenants(id)+);\ No newline at end of filediff --git a/vendor/github.com/aws/aws-sdk-go/LICENSE.txt b/vendor/github.com/aws/aws-sdk-go/LICENSE.txtnew file mode 100644index 000000000..d64569567--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/LICENSE.txt@@ -0,0 +1,202 @@++ Apache License+ Version 2.0, January 2004+ http://www.apache.org/licenses/++ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++ 1. Definitions.++ "License" shall mean the terms and conditions for use, reproduction,+ and distribution as defined by Sections 1 through 9 of this document.++ "Licensor" shall mean the copyright owner or entity authorized by+ the copyright owner that is granting the License.++ "Legal Entity" shall mean the union of the acting entity and all+ other entities that control, are controlled by, or are under common+ control with that entity. For the purposes of this definition,+ "control" means (i) the power, direct or indirect, to cause the+ direction or management of such entity, whether by contract or+ otherwise, or (ii) ownership of fifty percent (50%) or more of the+ outstanding shares, or (iii) beneficial ownership of such entity.++ "You" (or "Your") shall mean an individual or Legal Entity+ exercising permissions granted by this License.++ "Source" form shall mean the preferred form for making modifications,+ including but not limited to software source code, documentation+ source, and configuration files.++ "Object" form shall mean any form resulting from mechanical+ transformation or translation of a Source form, including but+ not limited to compiled object code, generated documentation,+ and conversions to other media types.++ "Work" shall mean the work of authorship, whether in Source or+ Object form, made available under the License, as indicated by a+ copyright notice that is included in or attached to the work+ (an example is provided in the Appendix below).++ "Derivative Works" shall mean any work, whether in Source or Object+ form, that is based on (or derived from) the Work and for which the+ editorial revisions, annotations, elaborations, or other modifications+ represent, as a whole, an original work of authorship. For the purposes+ of this License, Derivative Works shall not include works that remain+ separable from, or merely link (or bind by name) to the interfaces of,+ the Work and Derivative Works thereof.++ "Contribution" shall mean any work of authorship, including+ the original version of the Work and any modifications or additions+ to that Work or Derivative Works thereof, that is intentionally+ submitted to Licensor for inclusion in the Work by the copyright owner+ or by an individual or Legal Entity authorized to submit on behalf of+ the copyright owner. For the purposes of this definition, "submitted"+ means any form of electronic, verbal, or written communication sent+ to the Licensor or its representatives, including but not limited to+ communication on electronic mailing lists, source code control systems,+ and issue tracking systems that are managed by, or on behalf of, the+ Licensor for the purpose of discussing and improving the Work, but+ excluding communication that is conspicuously marked or otherwise+ designated in writing by the copyright owner as "Not a Contribution."++ "Contributor" shall mean Licensor and any individual or Legal Entity+ on behalf of whom a Contribution has been received by Licensor and+ subsequently incorporated within the Work.++ 2. Grant of Copyright License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ copyright license to reproduce, prepare Derivative Works of,+ publicly display, publicly perform, sublicense, and distribute the+ Work and such Derivative Works in Source or Object form.++ 3. Grant of Patent License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ (except as stated in this section) patent license to make, have made,+ use, offer to sell, sell, import, and otherwise transfer the Work,+ where such license applies only to those patent claims licensable+ by such Contributor that are necessarily infringed by their+ Contribution(s) alone or by combination of their Contribution(s)+ with the Work to which such Contribution(s) was submitted. If You+ institute patent litigation against any entity (including a+ cross-claim or counterclaim in a lawsuit) alleging that the Work+ or a Contribution incorporated within the Work constitutes direct+ or contributory patent infringement, then any patent licenses+ granted to You under this License for that Work shall terminate+ as of the date such litigation is filed.++ 4. Redistribution. You may reproduce and distribute copies of the+ Work or Derivative Works thereof in any medium, with or without+ modifications, and in Source or Object form, provided that You+ meet the following conditions:++ (a) You must give any other recipients of the Work or+ Derivative Works a copy of this License; and++ (b) You must cause any modified files to carry prominent notices+ stating that You changed the files; and++ (c) You must retain, in the Source form of any Derivative Works+ that You distribute, all copyright, patent, trademark, and+ attribution notices from the Source form of the Work,+ excluding those notices that do not pertain to any part of+ the Derivative Works; and++ (d) If the Work includes a "NOTICE" text file as part of its+ distribution, then any Derivative Works that You distribute must+ include a readable copy of the attribution notices contained+ within such NOTICE file, excluding those notices that do not+ pertain to any part of the Derivative Works, in at least one+ of the following places: within a NOTICE text file distributed+ as part of the Derivative Works; within the Source form or+ documentation, if provided along with the Derivative Works; or,+ within a display generated by the Derivative Works, if and+ wherever such third-party notices normally appear. The contents+ of the NOTICE file are for informational purposes only and+ do not modify the License. You may add Your own attribution+ notices within Derivative Works that You distribute, alongside+ or as an addendum to the NOTICE text from the Work, provided+ that such additional attribution notices cannot be construed+ as modifying the License.++ You may add Your own copyright statement to Your modifications and+ may provide additional or different license terms and conditions+ for use, reproduction, or distribution of Your modifications, or+ for any such Derivative Works as a whole, provided Your use,+ reproduction, and distribution of the Work otherwise complies with+ the conditions stated in this License.++ 5. Submission of Contributions. Unless You explicitly state otherwise,+ any Contribution intentionally submitted for inclusion in the Work+ by You to the Licensor shall be under the terms and conditions of+ this License, without any additional terms or conditions.+ Notwithstanding the above, nothing herein shall supersede or modify+ the terms of any separate license agreement you may have executed+ with Licensor regarding such Contributions.++ 6. Trademarks. This License does not grant permission to use the trade+ names, trademarks, service marks, or product names of the Licensor,+ except as required for reasonable and customary use in describing the+ origin of the Work and reproducing the content of the NOTICE file.++ 7. Disclaimer of Warranty. Unless required by applicable law or+ agreed to in writing, Licensor provides the Work (and each+ Contributor provides its Contributions) on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+ implied, including, without limitation, any warranties or conditions+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+ PARTICULAR PURPOSE. You are solely responsible for determining the+ appropriateness of using or redistributing the Work and assume any+ risks associated with Your exercise of permissions under this License.++ 8. Limitation of Liability. In no event and under no legal theory,+ whether in tort (including negligence), contract, or otherwise,+ unless required by applicable law (such as deliberate and grossly+ negligent acts) or agreed to in writing, shall any Contributor be+ liable to You for damages, including any direct, indirect, special,+ incidental, or consequential damages of any character arising as a+ result of this License or out of the use or inability to use the+ Work (including but not limited to damages for loss of goodwill,+ work stoppage, computer failure or malfunction, or any and all+ other commercial damages or losses), even if such Contributor+ has been advised of the possibility of such damages.++ 9. Accepting Warranty or Additional Liability. While redistributing+ the Work or Derivative Works thereof, You may choose to offer,+ and charge a fee for, acceptance of support, warranty, indemnity,+ or other liability obligations and/or rights consistent with this+ License. However, in accepting such obligations, You may act only+ on Your own behalf and on Your sole responsibility, not on behalf+ of any other Contributor, and only if You agree to indemnify,+ defend, and hold each Contributor harmless for any liability+ incurred by, or claims asserted against, such Contributor by reason+ of your accepting any such warranty or additional liability.++ END OF TERMS AND CONDITIONS++ APPENDIX: How to apply the Apache License to your work.++ To apply the Apache License to your work, attach the following+ boilerplate notice, with the fields enclosed by brackets "[]"+ replaced with your own identifying information. (Don't include+ the brackets!) The text should be enclosed in the appropriate+ comment syntax for the file format. We also recommend that a+ file or class name and description of purpose be included on the+ same "printed page" as the copyright notice for easier+ identification within third-party archives.++ Copyright [yyyy] [name of copyright owner]++ 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.diff --git a/vendor/github.com/aws/aws-sdk-go/NOTICE.txt b/vendor/github.com/aws/aws-sdk-go/NOTICE.txtnew file mode 100644index 000000000..5f14d1162--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/NOTICE.txt@@ -0,0 +1,3 @@+AWS SDK for Go+Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.+Copyright 2014-2015 Stripe, Inc.diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.go b/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.gonew file mode 100644index 000000000..56fdfc2bf--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awserr/error.go@@ -0,0 +1,145 @@+// Package awserr represents API error interface accessors for the SDK.+package awserr++// An Error wraps lower level errors with code, message and an original error.+// The underlying concrete error type may also satisfy other interfaces which+// can be to used to obtain more specific information about the error.+//+// Calling Error() or String() will always include the full information about+// an error based on its underlying type.+//+// Example:+//+// output, err := s3manage.Upload(svc, input, opts)+// if err != nil {+// if awsErr, ok := err.(awserr.Error); ok {+// // Get error details+// log.Println("Error:", awsErr.Code(), awsErr.Message())+//+// // Prints out full error message, including original error if there was one.+// log.Println("Error:", awsErr.Error())+//+// // Get original error+// if origErr := awsErr.OrigErr(); origErr != nil {+// // operate on original error.+// }+// } else {+// fmt.Println(err.Error())+// }+// }+//+type Error interface {+ // Satisfy the generic error interface.+ error++ // Returns the short phrase depicting the classification of the error.+ Code() string++ // Returns the error details message.+ Message() string++ // Returns the original error if one was set. Nil is returned if not set.+ OrigErr() error+}++// BatchError is a batch of errors which also wraps lower level errors with+// code, message, and original errors. Calling Error() will include all errors+// that occurred in the batch.+//+// Deprecated: Replaced with BatchedErrors. Only defined for backwards+// compatibility.+type BatchError interface {+ // Satisfy the generic error interface.+ error++ // Returns the short phrase depicting the classification of the error.+ Code() string++ // Returns the error details message.+ Message() string++ // Returns the original error if one was set. Nil is returned if not set.+ OrigErrs() []error+}++// BatchedErrors is a batch of errors which also wraps lower level errors with+// code, message, and original errors. Calling Error() will include all errors+// that occurred in the batch.+//+// Replaces BatchError+type BatchedErrors interface {+ // Satisfy the base Error interface.+ Error++ // Returns the original error if one was set. Nil is returned if not set.+ OrigErrs() []error+}++// New returns an Error object described by the code, message, and origErr.+//+// If origErr satisfies the Error interface it will not be wrapped within a new+// Error object and will instead be returned.+func New(code, message string, origErr error) Error {+ var errs []error+ if origErr != nil {+ errs = append(errs, origErr)+ }+ return newBaseError(code, message, errs)+}++// NewBatchError returns an BatchedErrors with a collection of errors as an+// array of errors.+func NewBatchError(code, message string, errs []error) BatchedErrors {+ return newBaseError(code, message, errs)+}++// A RequestFailure is an interface to extract request failure information from+// an Error such as the request ID of the failed request returned by a service.+// RequestFailures may not always have a requestID value if the request failed+// prior to reaching the service such as a connection error.+//+// Example:+//+// output, err := s3manage.Upload(svc, input, opts)+// if err != nil {+// if reqerr, ok := err.(RequestFailure); ok {+// log.Println("Request failed", reqerr.Code(), reqerr.Message(), reqerr.RequestID())+// } else {+// log.Println("Error:", err.Error())+// }+// }+//+// Combined with awserr.Error:+//+// output, err := s3manage.Upload(svc, input, opts)+// if err != nil {+// if awsErr, ok := err.(awserr.Error); ok {+// // Generic AWS Error with Code, Message, and original error (if any)+// fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())+//+// if reqErr, ok := err.(awserr.RequestFailure); ok {+// // A service error occurred+// fmt.Println(reqErr.StatusCode(), reqErr.RequestID())+// }+// } else {+// fmt.Println(err.Error())+// }+// }+//+type RequestFailure interface {+ Error++ // The status code of the HTTP response.+ StatusCode() int++ // The request ID returned by the service for a request failure. This will+ // be empty if no request ID is available such as the request failed due+ // to a connection error.+ RequestID() string+}++// NewRequestFailure returns a new request error wrapper for the given Error+// provided.+func NewRequestFailure(err Error, statusCode int, reqID string) RequestFailure {+ return newRequestError(err, statusCode, reqID)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.go b/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.gonew file mode 100644index 000000000..0202a008f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awserr/types.go@@ -0,0 +1,194 @@+package awserr++import "fmt"++// SprintError returns a string of the formatted error code.+//+// Both extra and origErr are optional. If they are included their lines+// will be added, but if they are not included their lines will be ignored.+func SprintError(code, message, extra string, origErr error) string {+ msg := fmt.Sprintf("%s: %s", code, message)+ if extra != "" {+ msg = fmt.Sprintf("%s\n\t%s", msg, extra)+ }+ if origErr != nil {+ msg = fmt.Sprintf("%s\ncaused by: %s", msg, origErr.Error())+ }+ return msg+}++// A baseError wraps the code and message which defines an error. It also+// can be used to wrap an original error object.+//+// Should be used as the root for errors satisfying the awserr.Error. Also+// for any error which does not fit into a specific error wrapper type.+type baseError struct {+ // Classification of error+ code string++ // Detailed information about error+ message string++ // Optional original error this error is based off of. Allows building+ // chained errors.+ errs []error+}++// newBaseError returns an error object for the code, message, and errors.+//+// code is a short no whitespace phrase depicting the classification of+// the error that is being created.+//+// message is the free flow string containing detailed information about the+// error.+//+// origErrs is the error objects which will be nested under the new errors to+// be returned.+func newBaseError(code, message string, origErrs []error) *baseError {+ b := &baseError{+ code: code,+ message: message,+ errs: origErrs,+ }++ return b+}++// Error returns the string representation of the error.+//+// See ErrorWithExtra for formatting.+//+// Satisfies the error interface.+func (b baseError) Error() string {+ size := len(b.errs)+ if size > 0 {+ return SprintError(b.code, b.message, "", errorList(b.errs))+ }++ return SprintError(b.code, b.message, "", nil)+}++// String returns the string representation of the error.+// Alias for Error to satisfy the stringer interface.+func (b baseError) String() string {+ return b.Error()+}++// Code returns the short phrase depicting the classification of the error.+func (b baseError) Code() string {+ return b.code+}++// Message returns the error details message.+func (b baseError) Message() string {+ return b.message+}++// OrigErr returns the original error if one was set. Nil is returned if no+// error was set. This only returns the first element in the list. If the full+// list is needed, use BatchedErrors.+func (b baseError) OrigErr() error {+ switch len(b.errs) {+ case 0:+ return nil+ case 1:+ return b.errs[0]+ default:+ if err, ok := b.errs[0].(Error); ok {+ return NewBatchError(err.Code(), err.Message(), b.errs[1:])+ }+ return NewBatchError("BatchedErrors",+ "multiple errors occurred", b.errs)+ }+}++// OrigErrs returns the original errors if one was set. An empty slice is+// returned if no error was set.+func (b baseError) OrigErrs() []error {+ return b.errs+}++// So that the Error interface type can be included as an anonymous field+// in the requestError struct and not conflict with the error.Error() method.+type awsError Error++// A requestError wraps a request or service error.+//+// Composed of baseError for code, message, and original error.+type requestError struct {+ awsError+ statusCode int+ requestID string+}++// newRequestError returns a wrapped error with additional information for+// request status code, and service requestID.+//+// Should be used to wrap all request which involve service requests. Even if+// the request failed without a service response, but had an HTTP status code+// that may be meaningful.+//+// Also wraps original errors via the baseError.+func newRequestError(err Error, statusCode int, requestID string) *requestError {+ return &requestError{+ awsError: err,+ statusCode: statusCode,+ requestID: requestID,+ }+}++// Error returns the string representation of the error.+// Satisfies the error interface.+func (r requestError) Error() string {+ extra := fmt.Sprintf("status code: %d, request id: %s",+ r.statusCode, r.requestID)+ return SprintError(r.Code(), r.Message(), extra, r.OrigErr())+}++// String returns the string representation of the error.+// Alias for Error to satisfy the stringer interface.+func (r requestError) String() string {+ return r.Error()+}++// StatusCode returns the wrapped status code for the error+func (r requestError) StatusCode() int {+ return r.statusCode+}++// RequestID returns the wrapped requestID+func (r requestError) RequestID() string {+ return r.requestID+}++// OrigErrs returns the original errors if one was set. An empty slice is+// returned if no error was set.+func (r requestError) OrigErrs() []error {+ if b, ok := r.awsError.(BatchedErrors); ok {+ return b.OrigErrs()+ }+ return []error{r.OrigErr()}+}++// An error list that satisfies the golang interface+type errorList []error++// Error returns the string representation of the error.+//+// Satisfies the error interface.+func (e errorList) Error() string {+ msg := ""+ // How do we want to handle the array size being zero+ if size := len(e); size > 0 {+ for i := 0; i < size; i++ {+ msg += fmt.Sprintf("%s", e[i].Error())+ // We check the next index to see if it is within the slice.+ // If it is, then we append a newline. We do this, because unit tests+ // could be broken with the additional '\n'+ if i+1 < size {+ msg += "\n"+ }+ }+ }+ return msg+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.gonew file mode 100644index 000000000..1a3d106d5--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/copy.go@@ -0,0 +1,108 @@+package awsutil++import (+ "io"+ "reflect"+ "time"+)++// Copy deeply copies a src structure to dst. Useful for copying request and+// response structures.+//+// Can copy between structs of different type, but will only copy fields which+// are assignable, and exist in both structs. Fields which are not assignable,+// or do not exist in both structs are ignored.+func Copy(dst, src interface{}) {+ dstval := reflect.ValueOf(dst)+ if !dstval.IsValid() {+ panic("Copy dst cannot be nil")+ }++ rcopy(dstval, reflect.ValueOf(src), true)+}++// CopyOf returns a copy of src while also allocating the memory for dst.+// src must be a pointer type or this operation will fail.+func CopyOf(src interface{}) (dst interface{}) {+ dsti := reflect.New(reflect.TypeOf(src).Elem())+ dst = dsti.Interface()+ rcopy(dsti, reflect.ValueOf(src), true)+ return+}++// rcopy performs a recursive copy of values from the source to destination.+//+// root is used to skip certain aspects of the copy which are not valid+// for the root node of a object.+func rcopy(dst, src reflect.Value, root bool) {+ if !src.IsValid() {+ return+ }++ switch src.Kind() {+ case reflect.Ptr:+ if _, ok := src.Interface().(io.Reader); ok {+ if dst.Kind() == reflect.Ptr && dst.Elem().CanSet() {+ dst.Elem().Set(src)+ } else if dst.CanSet() {+ dst.Set(src)+ }+ } else {+ e := src.Type().Elem()+ if dst.CanSet() && !src.IsNil() {+ if _, ok := src.Interface().(*time.Time); !ok {+ dst.Set(reflect.New(e))+ } else {+ tempValue := reflect.New(e)+ tempValue.Elem().Set(src.Elem())+ // Sets time.Time's unexported values+ dst.Set(tempValue)+ }+ }+ if src.Elem().IsValid() {+ // Keep the current root state since the depth hasn't changed+ rcopy(dst.Elem(), src.Elem(), root)+ }+ }+ case reflect.Struct:+ t := dst.Type()+ for i := 0; i < t.NumField(); i++ {+ name := t.Field(i).Name+ srcVal := src.FieldByName(name)+ dstVal := dst.FieldByName(name)+ if srcVal.IsValid() && dstVal.CanSet() {+ rcopy(dstVal, srcVal, false)+ }+ }+ case reflect.Slice:+ if src.IsNil() {+ break+ }++ s := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())+ dst.Set(s)+ for i := 0; i < src.Len(); i++ {+ rcopy(dst.Index(i), src.Index(i), false)+ }+ case reflect.Map:+ if src.IsNil() {+ break+ }++ s := reflect.MakeMap(src.Type())+ dst.Set(s)+ for _, k := range src.MapKeys() {+ v := src.MapIndex(k)+ v2 := reflect.New(v.Type()).Elem()+ rcopy(v2, v, false)+ dst.SetMapIndex(k, v2)+ }+ default:+ // Assign the value if possible. If its not assignable, the value would+ // need to be converted and the impact of that may be unexpected, or is+ // not compatible with the dst type.+ if src.Type().AssignableTo(dst.Type()) {+ dst.Set(src)+ }+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.gonew file mode 100644index 000000000..59fa4a558--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/equal.go@@ -0,0 +1,27 @@+package awsutil++import (+ "reflect"+)++// DeepEqual returns if the two values are deeply equal like reflect.DeepEqual.+// In addition to this, this method will also dereference the input values if+// possible so the DeepEqual performed will not fail if one parameter is a+// pointer and the other is not.+//+// DeepEqual will not perform indirection of nested values of the input parameters.+func DeepEqual(a, b interface{}) bool {+ ra := reflect.Indirect(reflect.ValueOf(a))+ rb := reflect.Indirect(reflect.ValueOf(b))++ if raValid, rbValid := ra.IsValid(), rb.IsValid(); !raValid && !rbValid {+ // If the elements are both nil, and of the same type the are equal+ // If they are of different types they are not equal+ return reflect.TypeOf(a) == reflect.TypeOf(b)+ } else if raValid != rbValid {+ // Both values must be valid to be equal+ return false+ }++ return reflect.DeepEqual(ra.Interface(), rb.Interface())+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.gonew file mode 100644index 000000000..11c52c389--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/path_value.go@@ -0,0 +1,222 @@+package awsutil++import (+ "reflect"+ "regexp"+ "strconv"+ "strings"++ "github.com/jmespath/go-jmespath"+)++var indexRe = regexp.MustCompile(`(.+)\[(-?\d+)?\]$`)++// rValuesAtPath returns a slice of values found in value v. The values+// in v are explored recursively so all nested values are collected.+func rValuesAtPath(v interface{}, path string, createPath, caseSensitive, nilTerm bool) []reflect.Value {+ pathparts := strings.Split(path, "||")+ if len(pathparts) > 1 {+ for _, pathpart := range pathparts {+ vals := rValuesAtPath(v, pathpart, createPath, caseSensitive, nilTerm)+ if len(vals) > 0 {+ return vals+ }+ }+ return nil+ }++ values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))}+ components := strings.Split(path, ".")+ for len(values) > 0 && len(components) > 0 {+ var index *int64+ var indexStar bool+ c := strings.TrimSpace(components[0])+ if c == "" { // no actual component, illegal syntax+ return nil+ } else if caseSensitive && c != "*" && strings.ToLower(c[0:1]) == c[0:1] {+ // TODO normalize case for user+ return nil // don't support unexported fields+ }++ // parse this component+ if m := indexRe.FindStringSubmatch(c); m != nil {+ c = m[1]+ if m[2] == "" {+ index = nil+ indexStar = true+ } else {+ i, _ := strconv.ParseInt(m[2], 10, 32)+ index = &i+ indexStar = false+ }+ }++ nextvals := []reflect.Value{}+ for _, value := range values {+ // pull component name out of struct member+ if value.Kind() != reflect.Struct {+ continue+ }++ if c == "*" { // pull all members+ for i := 0; i < value.NumField(); i++ {+ if f := reflect.Indirect(value.Field(i)); f.IsValid() {+ nextvals = append(nextvals, f)+ }+ }+ continue+ }++ value = value.FieldByNameFunc(func(name string) bool {+ if c == name {+ return true+ } else if !caseSensitive && strings.ToLower(name) == strings.ToLower(c) {+ return true+ }+ return false+ })++ if nilTerm && value.Kind() == reflect.Ptr && len(components[1:]) == 0 {+ if !value.IsNil() {+ value.Set(reflect.Zero(value.Type()))+ }+ return []reflect.Value{value}+ }++ if createPath && value.Kind() == reflect.Ptr && value.IsNil() {+ // TODO if the value is the terminus it should not be created+ // if the value to be set to its position is nil.+ value.Set(reflect.New(value.Type().Elem()))+ value = value.Elem()+ } else {+ value = reflect.Indirect(value)+ }++ if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {+ if !createPath && value.IsNil() {+ value = reflect.ValueOf(nil)+ }+ }++ if value.IsValid() {+ nextvals = append(nextvals, value)+ }+ }+ values = nextvals++ if indexStar || index != nil {+ nextvals = []reflect.Value{}+ for _, valItem := range values {+ value := reflect.Indirect(valItem)+ if value.Kind() != reflect.Slice {+ continue+ }++ if indexStar { // grab all indices+ for i := 0; i < value.Len(); i++ {+ idx := reflect.Indirect(value.Index(i))+ if idx.IsValid() {+ nextvals = append(nextvals, idx)+ }+ }+ continue+ }++ // pull out index+ i := int(*index)+ if i >= value.Len() { // check out of bounds+ if createPath {+ // TODO resize slice+ } else {+ continue+ }+ } else if i < 0 { // support negative indexing+ i = value.Len() + i+ }+ value = reflect.Indirect(value.Index(i))++ if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {+ if !createPath && value.IsNil() {+ value = reflect.ValueOf(nil)+ }+ }++ if value.IsValid() {+ nextvals = append(nextvals, value)+ }+ }+ values = nextvals+ }++ components = components[1:]+ }+ return values+}++// ValuesAtPath returns a list of values at the case insensitive lexical+// path inside of a structure.+func ValuesAtPath(i interface{}, path string) ([]interface{}, error) {+ result, err := jmespath.Search(path, i)+ if err != nil {+ return nil, err+ }++ v := reflect.ValueOf(result)+ if !v.IsValid() || (v.Kind() == reflect.Ptr && v.IsNil()) {+ return nil, nil+ }+ if s, ok := result.([]interface{}); ok {+ return s, err+ }+ if v.Kind() == reflect.Map && v.Len() == 0 {+ return nil, nil+ }+ if v.Kind() == reflect.Slice {+ out := make([]interface{}, v.Len())+ for i := 0; i < v.Len(); i++ {+ out[i] = v.Index(i).Interface()+ }+ return out, nil+ }++ return []interface{}{result}, nil+}++// SetValueAtPath sets a value at the case insensitive lexical path inside+// of a structure.+func SetValueAtPath(i interface{}, path string, v interface{}) {+ if rvals := rValuesAtPath(i, path, true, false, v == nil); rvals != nil {+ for _, rval := range rvals {+ if rval.Kind() == reflect.Ptr && rval.IsNil() {+ continue+ }+ setValue(rval, v)+ }+ }+}++func setValue(dstVal reflect.Value, src interface{}) {+ if dstVal.Kind() == reflect.Ptr {+ dstVal = reflect.Indirect(dstVal)+ }+ srcVal := reflect.ValueOf(src)++ if !srcVal.IsValid() { // src is literal nil+ if dstVal.CanAddr() {+ // Convert to pointer so that pointer's value can be nil'ed+ // dstVal = dstVal.Addr()+ }+ dstVal.Set(reflect.Zero(dstVal.Type()))++ } else if srcVal.Kind() == reflect.Ptr {+ if srcVal.IsNil() {+ srcVal = reflect.Zero(dstVal.Type())+ } else {+ srcVal = reflect.ValueOf(src).Elem()+ }+ dstVal.Set(srcVal)+ } else {+ dstVal.Set(srcVal)+ }++}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.gonew file mode 100644index 000000000..710eb432f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/prettify.go@@ -0,0 +1,113 @@+package awsutil++import (+ "bytes"+ "fmt"+ "io"+ "reflect"+ "strings"+)++// Prettify returns the string representation of a value.+func Prettify(i interface{}) string {+ var buf bytes.Buffer+ prettify(reflect.ValueOf(i), 0, &buf)+ return buf.String()+}++// prettify will recursively walk value v to build a textual+// representation of the value.+func prettify(v reflect.Value, indent int, buf *bytes.Buffer) {+ for v.Kind() == reflect.Ptr {+ v = v.Elem()+ }++ switch v.Kind() {+ case reflect.Struct:+ strtype := v.Type().String()+ if strtype == "time.Time" {+ fmt.Fprintf(buf, "%s", v.Interface())+ break+ } else if strings.HasPrefix(strtype, "io.") {+ buf.WriteString("<buffer>")+ break+ }++ buf.WriteString("{\n")++ names := []string{}+ for i := 0; i < v.Type().NumField(); i++ {+ name := v.Type().Field(i).Name+ f := v.Field(i)+ if name[0:1] == strings.ToLower(name[0:1]) {+ continue // ignore unexported fields+ }+ if (f.Kind() == reflect.Ptr || f.Kind() == reflect.Slice || f.Kind() == reflect.Map) && f.IsNil() {+ continue // ignore unset fields+ }+ names = append(names, name)+ }++ for i, n := range names {+ val := v.FieldByName(n)+ buf.WriteString(strings.Repeat(" ", indent+2))+ buf.WriteString(n + ": ")+ prettify(val, indent+2, buf)++ if i < len(names)-1 {+ buf.WriteString(",\n")+ }+ }++ buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")+ case reflect.Slice:+ strtype := v.Type().String()+ if strtype == "[]uint8" {+ fmt.Fprintf(buf, "<binary> len %d", v.Len())+ break+ }++ nl, id, id2 := "", "", ""+ if v.Len() > 3 {+ nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2)+ }+ buf.WriteString("[" + nl)+ for i := 0; i < v.Len(); i++ {+ buf.WriteString(id2)+ prettify(v.Index(i), indent+2, buf)++ if i < v.Len()-1 {+ buf.WriteString("," + nl)+ }+ }++ buf.WriteString(nl + id + "]")+ case reflect.Map:+ buf.WriteString("{\n")++ for i, k := range v.MapKeys() {+ buf.WriteString(strings.Repeat(" ", indent+2))+ buf.WriteString(k.String() + ": ")+ prettify(v.MapIndex(k), indent+2, buf)++ if i < v.Len()-1 {+ buf.WriteString(",\n")+ }+ }++ buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")+ default:+ if !v.IsValid() {+ fmt.Fprint(buf, "<invalid value>")+ return+ }+ format := "%v"+ switch v.Interface().(type) {+ case string:+ format = "%q"+ case io.ReadSeeker, io.Reader:+ format = "buffer(%p)"+ }+ fmt.Fprintf(buf, format, v.Interface())+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.go b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.gonew file mode 100644index 000000000..645df2450--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/awsutil/string_value.go@@ -0,0 +1,88 @@+package awsutil++import (+ "bytes"+ "fmt"+ "reflect"+ "strings"+)++// StringValue returns the string representation of a value.+func StringValue(i interface{}) string {+ var buf bytes.Buffer+ stringValue(reflect.ValueOf(i), 0, &buf)+ return buf.String()+}++func stringValue(v reflect.Value, indent int, buf *bytes.Buffer) {+ for v.Kind() == reflect.Ptr {+ v = v.Elem()+ }++ switch v.Kind() {+ case reflect.Struct:+ buf.WriteString("{\n")++ for i := 0; i < v.Type().NumField(); i++ {+ ft := v.Type().Field(i)+ fv := v.Field(i)++ if ft.Name[0:1] == strings.ToLower(ft.Name[0:1]) {+ continue // ignore unexported fields+ }+ if (fv.Kind() == reflect.Ptr || fv.Kind() == reflect.Slice) && fv.IsNil() {+ continue // ignore unset fields+ }++ buf.WriteString(strings.Repeat(" ", indent+2))+ buf.WriteString(ft.Name + ": ")++ if tag := ft.Tag.Get("sensitive"); tag == "true" {+ buf.WriteString("<sensitive>")+ } else {+ stringValue(fv, indent+2, buf)+ }++ buf.WriteString(",\n")+ }++ buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")+ case reflect.Slice:+ nl, id, id2 := "", "", ""+ if v.Len() > 3 {+ nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2)+ }+ buf.WriteString("[" + nl)+ for i := 0; i < v.Len(); i++ {+ buf.WriteString(id2)+ stringValue(v.Index(i), indent+2, buf)++ if i < v.Len()-1 {+ buf.WriteString("," + nl)+ }+ }++ buf.WriteString(nl + id + "]")+ case reflect.Map:+ buf.WriteString("{\n")++ for i, k := range v.MapKeys() {+ buf.WriteString(strings.Repeat(" ", indent+2))+ buf.WriteString(k.String() + ": ")+ stringValue(v.MapIndex(k), indent+2, buf)++ if i < v.Len()-1 {+ buf.WriteString(",\n")+ }+ }++ buf.WriteString("\n" + strings.Repeat(" ", indent) + "}")+ default:+ format := "%v"+ switch v.Interface().(type) {+ case string:+ format = "%q"+ }+ fmt.Fprintf(buf, format, v.Interface())+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/client.go b/vendor/github.com/aws/aws-sdk-go/aws/client/client.gonew file mode 100644index 000000000..212fe25e7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/client.go@@ -0,0 +1,96 @@+package client++import (+ "fmt"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/request"+)++// A Config provides configuration to a service client instance.+type Config struct {+ Config *aws.Config+ Handlers request.Handlers+ Endpoint string+ SigningRegion string+ SigningName string++ // States that the signing name did not come from a modeled source but+ // was derived based on other data. Used by service client constructors+ // to determine if the signin name can be overriden based on metadata the+ // service has.+ SigningNameDerived bool+}++// ConfigProvider provides a generic way for a service client to receive+// the ClientConfig without circular dependencies.+type ConfigProvider interface {+ ClientConfig(serviceName string, cfgs ...*aws.Config) Config+}++// ConfigNoResolveEndpointProvider same as ConfigProvider except it will not+// resolve the endpoint automatically. The service client's endpoint must be+// provided via the aws.Config.Endpoint field.+type ConfigNoResolveEndpointProvider interface {+ ClientConfigNoResolveEndpoint(cfgs ...*aws.Config) Config+}++// A Client implements the base client request and response handling+// used by all service clients.+type Client struct {+ request.Retryer+ metadata.ClientInfo++ Config aws.Config+ Handlers request.Handlers+}++// New will return a pointer to a new initialized service client.+func New(cfg aws.Config, info metadata.ClientInfo, handlers request.Handlers, options ...func(*Client)) *Client {+ svc := &Client{+ Config: cfg,+ ClientInfo: info,+ Handlers: handlers.Copy(),+ }++ switch retryer, ok := cfg.Retryer.(request.Retryer); {+ case ok:+ svc.Retryer = retryer+ case cfg.Retryer != nil && cfg.Logger != nil:+ s := fmt.Sprintf("WARNING: %T does not implement request.Retryer; using DefaultRetryer instead", cfg.Retryer)+ cfg.Logger.Log(s)+ fallthrough+ default:+ maxRetries := aws.IntValue(cfg.MaxRetries)+ if cfg.MaxRetries == nil || maxRetries == aws.UseServiceDefaultRetries {+ maxRetries = 3+ }+ svc.Retryer = DefaultRetryer{NumMaxRetries: maxRetries}+ }++ svc.AddDebugHandlers()++ for _, option := range options {+ option(svc)+ }++ return svc+}++// NewRequest returns a new Request pointer for the service API+// operation and parameters.+func (c *Client) NewRequest(operation *request.Operation, params interface{}, data interface{}) *request.Request {+ return request.New(c.Config, c.ClientInfo, c.Handlers, c.Retryer, operation, params, data)+}++// AddDebugHandlers injects debug logging handlers into the service to log request+// debug information.+func (c *Client) AddDebugHandlers() {+ if !c.Config.LogLevel.AtLeast(aws.LogDebug) {+ return+ }++ c.Handlers.Send.PushFrontNamed(LogHTTPRequestHandler)+ c.Handlers.Send.PushBackNamed(LogHTTPResponseHandler)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.go b/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.gonew file mode 100644index 000000000..a397b0d04--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/default_retryer.go@@ -0,0 +1,116 @@+package client++import (+ "strconv"+ "time"++ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/sdkrand"+)++// DefaultRetryer implements basic retry logic using exponential backoff for+// most services. If you want to implement custom retry logic, implement the+// request.Retryer interface or create a structure type that composes this+// struct and override the specific methods. For example, to override only+// the MaxRetries method:+//+// type retryer struct {+// client.DefaultRetryer+// }+//+// // This implementation always has 100 max retries+// func (d retryer) MaxRetries() int { return 100 }+type DefaultRetryer struct {+ NumMaxRetries int+}++// MaxRetries returns the number of maximum returns the service will use to make+// an individual API request.+func (d DefaultRetryer) MaxRetries() int {+ return d.NumMaxRetries+}++// RetryRules returns the delay duration before retrying this request again+func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {+ // Set the upper limit of delay in retrying at ~five minutes+ minTime := 30+ throttle := d.shouldThrottle(r)+ if throttle {+ if delay, ok := getRetryDelay(r); ok {+ return delay+ }++ minTime = 500+ }++ retryCount := r.RetryCount+ if throttle && retryCount > 8 {+ retryCount = 8+ } else if retryCount > 13 {+ retryCount = 13+ }++ delay := (1 << uint(retryCount)) * (sdkrand.SeededRand.Intn(minTime) + minTime)+ return time.Duration(delay) * time.Millisecond+}++// ShouldRetry returns true if the request should be retried.+func (d DefaultRetryer) ShouldRetry(r *request.Request) bool {+ // If one of the other handlers already set the retry state+ // we don't want to override it based on the service's state+ if r.Retryable != nil {+ return *r.Retryable+ }++ if r.HTTPResponse.StatusCode >= 500 && r.HTTPResponse.StatusCode != 501 {+ return true+ }+ return r.IsErrorRetryable() || d.shouldThrottle(r)+}++// ShouldThrottle returns true if the request should be throttled.+func (d DefaultRetryer) shouldThrottle(r *request.Request) bool {+ switch r.HTTPResponse.StatusCode {+ case 429:+ case 502:+ case 503:+ case 504:+ default:+ return r.IsErrorThrottle()+ }++ return true+}++// This will look in the Retry-After header, RFC 7231, for how long+// it will wait before attempting another request+func getRetryDelay(r *request.Request) (time.Duration, bool) {+ if !canUseRetryAfterHeader(r) {+ return 0, false+ }++ delayStr := r.HTTPResponse.Header.Get("Retry-After")+ if len(delayStr) == 0 {+ return 0, false+ }++ delay, err := strconv.Atoi(delayStr)+ if err != nil {+ return 0, false+ }++ return time.Duration(delay) * time.Second, true+}++// Will look at the status code to see if the retry header pertains to+// the status code.+func canUseRetryAfterHeader(r *request.Request) bool {+ switch r.HTTPResponse.StatusCode {+ case 429:+ case 503:+ default:+ return false+ }++ return true+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/logger.go b/vendor/github.com/aws/aws-sdk-go/aws/client/logger.gonew file mode 100644index 000000000..ce9fb896d--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/logger.go@@ -0,0 +1,184 @@+package client++import (+ "bytes"+ "fmt"+ "io"+ "io/ioutil"+ "net/http/httputil"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/request"+)++const logReqMsg = `DEBUG: Request %s/%s Details:+---[ REQUEST POST-SIGN ]-----------------------------+%s+-----------------------------------------------------`++const logReqErrMsg = `DEBUG ERROR: Request %s/%s:+---[ REQUEST DUMP ERROR ]-----------------------------+%s+------------------------------------------------------`++type logWriter struct {+ // Logger is what we will use to log the payload of a response.+ Logger aws.Logger+ // buf stores the contents of what has been read+ buf *bytes.Buffer+}++func (logger *logWriter) Write(b []byte) (int, error) {+ return logger.buf.Write(b)+}++type teeReaderCloser struct {+ // io.Reader will be a tee reader that is used during logging.+ // This structure will read from a body and write the contents to a logger.+ io.Reader+ // Source is used just to close when we are done reading.+ Source io.ReadCloser+}++func (reader *teeReaderCloser) Close() error {+ return reader.Source.Close()+}++// LogHTTPRequestHandler is a SDK request handler to log the HTTP request sent+// to a service. Will include the HTTP request body if the LogLevel of the+// request matches LogDebugWithHTTPBody.+var LogHTTPRequestHandler = request.NamedHandler{+ Name: "awssdk.client.LogRequest",+ Fn: logRequest,+}++func logRequest(r *request.Request) {+ logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)+ bodySeekable := aws.IsReaderSeekable(r.Body)++ b, err := httputil.DumpRequestOut(r.HTTPRequest, logBody)+ if err != nil {+ r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, err))+ return+ }++ if logBody {+ if !bodySeekable {+ r.SetReaderBody(aws.ReadSeekCloser(r.HTTPRequest.Body))+ }+ // Reset the request body because dumpRequest will re-wrap the r.HTTPRequest's+ // Body as a NoOpCloser and will not be reset after read by the HTTP+ // client reader.+ r.ResetBody()+ }++ r.Config.Logger.Log(fmt.Sprintf(logReqMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, string(b)))+}++// LogHTTPRequestHeaderHandler is a SDK request handler to log the HTTP request sent+// to a service. Will only log the HTTP request's headers. The request payload+// will not be read.+var LogHTTPRequestHeaderHandler = request.NamedHandler{+ Name: "awssdk.client.LogRequestHeader",+ Fn: logRequestHeader,+}++func logRequestHeader(r *request.Request) {+ b, err := httputil.DumpRequestOut(r.HTTPRequest, false)+ if err != nil {+ r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, err))+ return+ }++ r.Config.Logger.Log(fmt.Sprintf(logReqMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, string(b)))+}++const logRespMsg = `DEBUG: Response %s/%s Details:+---[ RESPONSE ]--------------------------------------+%s+-----------------------------------------------------`++const logRespErrMsg = `DEBUG ERROR: Response %s/%s:+---[ RESPONSE DUMP ERROR ]-----------------------------+%s+-----------------------------------------------------`++// LogHTTPResponseHandler is a SDK request handler to log the HTTP response+// received from a service. Will include the HTTP response body if the LogLevel+// of the request matches LogDebugWithHTTPBody.+var LogHTTPResponseHandler = request.NamedHandler{+ Name: "awssdk.client.LogResponse",+ Fn: logResponse,+}++func logResponse(r *request.Request) {+ lw := &logWriter{r.Config.Logger, bytes.NewBuffer(nil)}++ logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)+ if logBody {+ r.HTTPResponse.Body = &teeReaderCloser{+ Reader: io.TeeReader(r.HTTPResponse.Body, lw),+ Source: r.HTTPResponse.Body,+ }+ }++ handlerFn := func(req *request.Request) {+ b, err := httputil.DumpResponse(req.HTTPResponse, false)+ if err != nil {+ lw.Logger.Log(fmt.Sprintf(logRespErrMsg,+ req.ClientInfo.ServiceName, req.Operation.Name, err))+ return+ }++ lw.Logger.Log(fmt.Sprintf(logRespMsg,+ req.ClientInfo.ServiceName, req.Operation.Name, string(b)))++ if logBody {+ b, err := ioutil.ReadAll(lw.buf)+ if err != nil {+ lw.Logger.Log(fmt.Sprintf(logRespErrMsg,+ req.ClientInfo.ServiceName, req.Operation.Name, err))+ return+ }++ lw.Logger.Log(string(b))+ }+ }++ const handlerName = "awsdk.client.LogResponse.ResponseBody"++ r.Handlers.Unmarshal.SetBackNamed(request.NamedHandler{+ Name: handlerName, Fn: handlerFn,+ })+ r.Handlers.UnmarshalError.SetBackNamed(request.NamedHandler{+ Name: handlerName, Fn: handlerFn,+ })+}++// LogHTTPResponseHeaderHandler is a SDK request handler to log the HTTP+// response received from a service. Will only log the HTTP response's headers.+// The response payload will not be read.+var LogHTTPResponseHeaderHandler = request.NamedHandler{+ Name: "awssdk.client.LogResponseHeader",+ Fn: logResponseHeader,+}++func logResponseHeader(r *request.Request) {+ if r.Config.Logger == nil {+ return+ }++ b, err := httputil.DumpResponse(r.HTTPResponse, false)+ if err != nil {+ r.Config.Logger.Log(fmt.Sprintf(logRespErrMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, err))+ return+ }++ r.Config.Logger.Log(fmt.Sprintf(logRespMsg,+ r.ClientInfo.ServiceName, r.Operation.Name, string(b)))+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go b/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.gonew file mode 100644index 000000000..920e9fddf--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go@@ -0,0 +1,13 @@+package metadata++// ClientInfo wraps immutable data from the client.Client structure.+type ClientInfo struct {+ ServiceName string+ ServiceID string+ APIVersion string+ Endpoint string+ SigningName string+ SigningRegion string+ JSONVersion string+ TargetPrefix string+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/config.go b/vendor/github.com/aws/aws-sdk-go/aws/config.gonew file mode 100644index 000000000..10634d173--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/config.go@@ -0,0 +1,536 @@+package aws++import (+ "net/http"+ "time"++ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/endpoints"+)++// UseServiceDefaultRetries instructs the config to use the service's own+// default number of retries. This will be the default action if+// Config.MaxRetries is nil also.+const UseServiceDefaultRetries = -1++// RequestRetryer is an alias for a type that implements the request.Retryer+// interface.+type RequestRetryer interface{}++// A Config provides service configuration for service clients. By default,+// all clients will use the defaults.DefaultConfig structure.+//+// // Create Session with MaxRetry configuration to be shared by multiple+// // service clients.+// sess := session.Must(session.NewSession(&aws.Config{+// MaxRetries: aws.Int(3),+// }))+//+// // Create S3 service client with a specific Region.+// svc := s3.New(sess, &aws.Config{+// Region: aws.String("us-west-2"),+// })+type Config struct {+ // Enables verbose error printing of all credential chain errors.+ // Should be used when wanting to see all errors while attempting to+ // retrieve credentials.+ CredentialsChainVerboseErrors *bool++ // The credentials object to use when signing requests. Defaults to a+ // chain of credential providers to search for credentials in environment+ // variables, shared credential file, and EC2 Instance Roles.+ Credentials *credentials.Credentials++ // An optional endpoint URL (hostname only or fully qualified URI)+ // that overrides the default generated endpoint for a client. Set this+ // to `""` to use the default generated endpoint.+ //+ // Note: You must still provide a `Region` value when specifying an+ // endpoint for a client.+ Endpoint *string++ // The resolver to use for looking up endpoints for AWS service clients+ // to use based on region.+ EndpointResolver endpoints.Resolver++ // EnforceShouldRetryCheck is used in the AfterRetryHandler to always call+ // ShouldRetry regardless of whether or not if request.Retryable is set.+ // This will utilize ShouldRetry method of custom retryers. If EnforceShouldRetryCheck+ // is not set, then ShouldRetry will only be called if request.Retryable is nil.+ // Proper handling of the request.Retryable field is important when setting this field.+ EnforceShouldRetryCheck *bool++ // The region to send requests to. This parameter is required and must+ // be configured globally or on a per-client basis unless otherwise+ // noted. A full list of regions is found in the "Regions and Endpoints"+ // document.+ //+ // See http://docs.aws.amazon.com/general/latest/gr/rande.html for AWS+ // Regions and Endpoints.+ Region *string++ // Set this to `true` to disable SSL when sending requests. Defaults+ // to `false`.+ DisableSSL *bool++ // The HTTP client to use when sending requests. Defaults to+ // `http.DefaultClient`.+ HTTPClient *http.Client++ // An integer value representing the logging level. The default log level+ // is zero (LogOff), which represents no logging. To enable logging set+ // to a LogLevel Value.+ LogLevel *LogLevelType++ // The logger writer interface to write logging messages to. Defaults to+ // standard out.+ Logger Logger++ // The maximum number of times that a request will be retried for failures.+ // Defaults to -1, which defers the max retry setting to the service+ // specific configuration.+ MaxRetries *int++ // Retryer guides how HTTP requests should be retried in case of+ // recoverable failures.+ //+ // When nil or the value does not implement the request.Retryer interface,+ // the client.DefaultRetryer will be used.+ //+ // When both Retryer and MaxRetries are non-nil, the former is used and+ // the latter ignored.+ //+ // To set the Retryer field in a type-safe manner and with chaining, use+ // the request.WithRetryer helper function:+ //+ // cfg := request.WithRetryer(aws.NewConfig(), myRetryer)+ //+ Retryer RequestRetryer++ // Disables semantic parameter validation, which validates input for+ // missing required fields and/or other semantic request input errors.+ DisableParamValidation *bool++ // Disables the computation of request and response checksums, e.g.,+ // CRC32 checksums in Amazon DynamoDB.+ DisableComputeChecksums *bool++ // Set this to `true` to force the request to use path-style addressing,+ // i.e., `http://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client+ // will use virtual hosted bucket addressing when possible+ // (`http://BUCKET.s3.amazonaws.com/KEY`).+ //+ // Note: This configuration option is specific to the Amazon S3 service.+ //+ // See http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html+ // for Amazon S3: Virtual Hosting of Buckets+ S3ForcePathStyle *bool++ // Set this to `true` to disable the SDK adding the `Expect: 100-Continue`+ // header to PUT requests over 2MB of content. 100-Continue instructs the+ // HTTP client not to send the body until the service responds with a+ // `continue` status. This is useful to prevent sending the request body+ // until after the request is authenticated, and validated.+ //+ // http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html+ //+ // 100-Continue is only enabled for Go 1.6 and above. See `http.Transport`'s+ // `ExpectContinueTimeout` for information on adjusting the continue wait+ // timeout. https://golang.org/pkg/net/http/#Transport+ //+ // You should use this flag to disble 100-Continue if you experience issues+ // with proxies or third party S3 compatible services.+ S3Disable100Continue *bool++ // Set this to `true` to enable S3 Accelerate feature. For all operations+ // compatible with S3 Accelerate will use the accelerate endpoint for+ // requests. Requests not compatible will fall back to normal S3 requests.+ //+ // The bucket must be enable for accelerate to be used with S3 client with+ // accelerate enabled. If the bucket is not enabled for accelerate an error+ // will be returned. The bucket name must be DNS compatible to also work+ // with accelerate.+ S3UseAccelerate *bool++ // S3DisableContentMD5Validation config option is temporarily disabled,+ // For S3 GetObject API calls, #1837.+ //+ // Set this to `true` to disable the S3 service client from automatically+ // adding the ContentMD5 to S3 Object Put and Upload API calls. This option+ // will also disable the SDK from performing object ContentMD5 validation+ // on GetObject API calls.+ S3DisableContentMD5Validation *bool++ // Set this to `true` to disable the EC2Metadata client from overriding the+ // default http.Client's Timeout. This is helpful if you do not want the+ // EC2Metadata client to create a new http.Client. This options is only+ // meaningful if you're not already using a custom HTTP client with the+ // SDK. Enabled by default.+ //+ // Must be set and provided to the session.NewSession() in order to disable+ // the EC2Metadata overriding the timeout for default credentials chain.+ //+ // Example:+ // sess := session.Must(session.NewSession(aws.NewConfig()+ // .WithEC2MetadataDiableTimeoutOverride(true)))+ //+ // svc := s3.New(sess)+ //+ EC2MetadataDisableTimeoutOverride *bool++ // Instructs the endpoint to be generated for a service client to+ // be the dual stack endpoint. The dual stack endpoint will support+ // both IPv4 and IPv6 addressing.+ //+ // Setting this for a service which does not support dual stack will fail+ // to make requets. It is not recommended to set this value on the session+ // as it will apply to all service clients created with the session. Even+ // services which don't support dual stack endpoints.+ //+ // If the Endpoint config value is also provided the UseDualStack flag+ // will be ignored.+ //+ // Only supported with.+ //+ // sess := session.Must(session.NewSession())+ //+ // svc := s3.New(sess, &aws.Config{+ // UseDualStack: aws.Bool(true),+ // })+ UseDualStack *bool++ // SleepDelay is an override for the func the SDK will call when sleeping+ // during the lifecycle of a request. Specifically this will be used for+ // request delays. This value should only be used for testing. To adjust+ // the delay of a request see the aws/client.DefaultRetryer and+ // aws/request.Retryer.+ //+ // SleepDelay will prevent any Context from being used for canceling retry+ // delay of an API operation. It is recommended to not use SleepDelay at all+ // and specify a Retryer instead.+ SleepDelay func(time.Duration)++ // DisableRestProtocolURICleaning will not clean the URL path when making rest protocol requests.+ // Will default to false. This would only be used for empty directory names in s3 requests.+ //+ // Example:+ // sess := session.Must(session.NewSession(&aws.Config{+ // DisableRestProtocolURICleaning: aws.Bool(true),+ // }))+ //+ // svc := s3.New(sess)+ // out, err := svc.GetObject(&s3.GetObjectInput {+ // Bucket: aws.String("bucketname"),+ // Key: aws.String("//foo//bar//moo"),+ // })+ DisableRestProtocolURICleaning *bool++ // EnableEndpointDiscovery will allow for endpoint discovery on operations that+ // have the definition in its model. By default, endpoint discovery is off.+ //+ // Example:+ // sess := session.Must(session.NewSession(&aws.Config{+ // EnableEndpointDiscovery: aws.Bool(true),+ // }))+ //+ // svc := s3.New(sess)+ // out, err := svc.GetObject(&s3.GetObjectInput {+ // Bucket: aws.String("bucketname"),+ // Key: aws.String("/foo/bar/moo"),+ // })+ EnableEndpointDiscovery *bool++ // DisableEndpointHostPrefix will disable the SDK's behavior of prefixing+ // request endpoint hosts with modeled information.+ //+ // Disabling this feature is useful when you want to use local endpoints+ // for testing that do not support the modeled host prefix pattern.+ DisableEndpointHostPrefix *bool+}++// NewConfig returns a new Config pointer that can be chained with builder+// methods to set multiple configuration values inline without using pointers.+//+// // Create Session with MaxRetry configuration to be shared by multiple+// // service clients.+// sess := session.Must(session.NewSession(aws.NewConfig().+// WithMaxRetries(3),+// ))+//+// // Create S3 service client with a specific Region.+// svc := s3.New(sess, aws.NewConfig().+// WithRegion("us-west-2"),+// )+func NewConfig() *Config {+ return &Config{}+}++// WithCredentialsChainVerboseErrors sets a config verbose errors boolean and returning+// a Config pointer.+func (c *Config) WithCredentialsChainVerboseErrors(verboseErrs bool) *Config {+ c.CredentialsChainVerboseErrors = &verboseErrs+ return c+}++// WithCredentials sets a config Credentials value returning a Config pointer+// for chaining.+func (c *Config) WithCredentials(creds *credentials.Credentials) *Config {+ c.Credentials = creds+ return c+}++// WithEndpoint sets a config Endpoint value returning a Config pointer for+// chaining.+func (c *Config) WithEndpoint(endpoint string) *Config {+ c.Endpoint = &endpoint+ return c+}++// WithEndpointResolver sets a config EndpointResolver value returning a+// Config pointer for chaining.+func (c *Config) WithEndpointResolver(resolver endpoints.Resolver) *Config {+ c.EndpointResolver = resolver+ return c+}++// WithRegion sets a config Region value returning a Config pointer for+// chaining.+func (c *Config) WithRegion(region string) *Config {+ c.Region = ®ion+ return c+}++// WithDisableSSL sets a config DisableSSL value returning a Config pointer+// for chaining.+func (c *Config) WithDisableSSL(disable bool) *Config {+ c.DisableSSL = &disable+ return c+}++// WithHTTPClient sets a config HTTPClient value returning a Config pointer+// for chaining.+func (c *Config) WithHTTPClient(client *http.Client) *Config {+ c.HTTPClient = client+ return c+}++// WithMaxRetries sets a config MaxRetries value returning a Config pointer+// for chaining.+func (c *Config) WithMaxRetries(max int) *Config {+ c.MaxRetries = &max+ return c+}++// WithDisableParamValidation sets a config DisableParamValidation value+// returning a Config pointer for chaining.+func (c *Config) WithDisableParamValidation(disable bool) *Config {+ c.DisableParamValidation = &disable+ return c+}++// WithDisableComputeChecksums sets a config DisableComputeChecksums value+// returning a Config pointer for chaining.+func (c *Config) WithDisableComputeChecksums(disable bool) *Config {+ c.DisableComputeChecksums = &disable+ return c+}++// WithLogLevel sets a config LogLevel value returning a Config pointer for+// chaining.+func (c *Config) WithLogLevel(level LogLevelType) *Config {+ c.LogLevel = &level+ return c+}++// WithLogger sets a config Logger value returning a Config pointer for+// chaining.+func (c *Config) WithLogger(logger Logger) *Config {+ c.Logger = logger+ return c+}++// WithS3ForcePathStyle sets a config S3ForcePathStyle value returning a Config+// pointer for chaining.+func (c *Config) WithS3ForcePathStyle(force bool) *Config {+ c.S3ForcePathStyle = &force+ return c+}++// WithS3Disable100Continue sets a config S3Disable100Continue value returning+// a Config pointer for chaining.+func (c *Config) WithS3Disable100Continue(disable bool) *Config {+ c.S3Disable100Continue = &disable+ return c+}++// WithS3UseAccelerate sets a config S3UseAccelerate value returning a Config+// pointer for chaining.+func (c *Config) WithS3UseAccelerate(enable bool) *Config {+ c.S3UseAccelerate = &enable+ return c++}++// WithS3DisableContentMD5Validation sets a config+// S3DisableContentMD5Validation value returning a Config pointer for chaining.+func (c *Config) WithS3DisableContentMD5Validation(enable bool) *Config {+ c.S3DisableContentMD5Validation = &enable+ return c++}++// WithUseDualStack sets a config UseDualStack value returning a Config+// pointer for chaining.+func (c *Config) WithUseDualStack(enable bool) *Config {+ c.UseDualStack = &enable+ return c+}++// WithEC2MetadataDisableTimeoutOverride sets a config EC2MetadataDisableTimeoutOverride value+// returning a Config pointer for chaining.+func (c *Config) WithEC2MetadataDisableTimeoutOverride(enable bool) *Config {+ c.EC2MetadataDisableTimeoutOverride = &enable+ return c+}++// WithSleepDelay overrides the function used to sleep while waiting for the+// next retry. Defaults to time.Sleep.+func (c *Config) WithSleepDelay(fn func(time.Duration)) *Config {+ c.SleepDelay = fn+ return c+}++// WithEndpointDiscovery will set whether or not to use endpoint discovery.+func (c *Config) WithEndpointDiscovery(t bool) *Config {+ c.EnableEndpointDiscovery = &t+ return c+}++// WithDisableEndpointHostPrefix will set whether or not to use modeled host prefix+// when making requests.+func (c *Config) WithDisableEndpointHostPrefix(t bool) *Config {+ c.DisableEndpointHostPrefix = &t+ return c+}++// MergeIn merges the passed in configs into the existing config object.+func (c *Config) MergeIn(cfgs ...*Config) {+ for _, other := range cfgs {+ mergeInConfig(c, other)+ }+}++func mergeInConfig(dst *Config, other *Config) {+ if other == nil {+ return+ }++ if other.CredentialsChainVerboseErrors != nil {+ dst.CredentialsChainVerboseErrors = other.CredentialsChainVerboseErrors+ }++ if other.Credentials != nil {+ dst.Credentials = other.Credentials+ }++ if other.Endpoint != nil {+ dst.Endpoint = other.Endpoint+ }++ if other.EndpointResolver != nil {+ dst.EndpointResolver = other.EndpointResolver+ }++ if other.Region != nil {+ dst.Region = other.Region+ }++ if other.DisableSSL != nil {+ dst.DisableSSL = other.DisableSSL+ }++ if other.HTTPClient != nil {+ dst.HTTPClient = other.HTTPClient+ }++ if other.LogLevel != nil {+ dst.LogLevel = other.LogLevel+ }++ if other.Logger != nil {+ dst.Logger = other.Logger+ }++ if other.MaxRetries != nil {+ dst.MaxRetries = other.MaxRetries+ }++ if other.Retryer != nil {+ dst.Retryer = other.Retryer+ }++ if other.DisableParamValidation != nil {+ dst.DisableParamValidation = other.DisableParamValidation+ }++ if other.DisableComputeChecksums != nil {+ dst.DisableComputeChecksums = other.DisableComputeChecksums+ }++ if other.S3ForcePathStyle != nil {+ dst.S3ForcePathStyle = other.S3ForcePathStyle+ }++ if other.S3Disable100Continue != nil {+ dst.S3Disable100Continue = other.S3Disable100Continue+ }++ if other.S3UseAccelerate != nil {+ dst.S3UseAccelerate = other.S3UseAccelerate+ }++ if other.S3DisableContentMD5Validation != nil {+ dst.S3DisableContentMD5Validation = other.S3DisableContentMD5Validation+ }++ if other.UseDualStack != nil {+ dst.UseDualStack = other.UseDualStack+ }++ if other.EC2MetadataDisableTimeoutOverride != nil {+ dst.EC2MetadataDisableTimeoutOverride = other.EC2MetadataDisableTimeoutOverride+ }++ if other.SleepDelay != nil {+ dst.SleepDelay = other.SleepDelay+ }++ if other.DisableRestProtocolURICleaning != nil {+ dst.DisableRestProtocolURICleaning = other.DisableRestProtocolURICleaning+ }++ if other.EnforceShouldRetryCheck != nil {+ dst.EnforceShouldRetryCheck = other.EnforceShouldRetryCheck+ }++ if other.EnableEndpointDiscovery != nil {+ dst.EnableEndpointDiscovery = other.EnableEndpointDiscovery+ }++ if other.DisableEndpointHostPrefix != nil {+ dst.DisableEndpointHostPrefix = other.DisableEndpointHostPrefix+ }+}++// Copy will return a shallow copy of the Config object. If any additional+// configurations are provided they will be merged into the new config returned.+func (c *Config) Copy(cfgs ...*Config) *Config {+ dst := &Config{}+ dst.MergeIn(c)++ for _, cfg := range cfgs {+ dst.MergeIn(cfg)+ }++ return dst+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context.go b/vendor/github.com/aws/aws-sdk-go/aws/context.gonew file mode 100644index 000000000..79f426853--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/context.go@@ -0,0 +1,71 @@+package aws++import (+ "time"+)++// Context is an copy of the Go v1.7 stdlib's context.Context interface.+// It is represented as a SDK interface to enable you to use the "WithContext"+// API methods with Go v1.6 and a Context type such as golang.org/x/net/context.+//+// See https://golang.org/pkg/context on how to use contexts.+type Context interface {+ // Deadline returns the time when work done on behalf of this context+ // should be canceled. Deadline returns ok==false when no deadline is+ // set. Successive calls to Deadline return the same results.+ Deadline() (deadline time.Time, ok bool)++ // Done returns a channel that's closed when work done on behalf of this+ // context should be canceled. Done may return nil if this context can+ // never be canceled. Successive calls to Done return the same value.+ Done() <-chan struct{}++ // Err returns a non-nil error value after Done is closed. Err returns+ // Canceled if the context was canceled or DeadlineExceeded if the+ // context's deadline passed. No other values for Err are defined.+ // After Done is closed, successive calls to Err return the same value.+ Err() error++ // Value returns the value associated with this context for key, or nil+ // if no value is associated with key. Successive calls to Value with+ // the same key returns the same result.+ //+ // Use context values only for request-scoped data that transits+ // processes and API boundaries, not for passing optional parameters to+ // functions.+ Value(key interface{}) interface{}+}++// BackgroundContext returns a context that will never be canceled, has no+// values, and no deadline. This context is used by the SDK to provide+// backwards compatibility with non-context API operations and functionality.+//+// Go 1.6 and before:+// This context function is equivalent to context.Background in the Go stdlib.+//+// Go 1.7 and later:+// The context returned will be the value returned by context.Background()+//+// See https://golang.org/pkg/context for more information on Contexts.+func BackgroundContext() Context {+ return backgroundCtx+}++// SleepWithContext will wait for the timer duration to expire, or the context+// is canceled. Which ever happens first. If the context is canceled the Context's+// error will be returned.+//+// Expects Context to always return a non-nil error if the Done channel is closed.+func SleepWithContext(ctx Context, dur time.Duration) error {+ t := time.NewTimer(dur)+ defer t.Stop()++ select {+ case <-t.C:+ break+ case <-ctx.Done():+ return ctx.Err()+ }++ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.go b/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.gonew file mode 100644index 000000000..8fdda5303--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/context_1_6.go@@ -0,0 +1,41 @@+// +build !go1.7++package aws++import "time"++// An emptyCtx is a copy of the Go 1.7 context.emptyCtx type. This is copied to+// provide a 1.6 and 1.5 safe version of context that is compatible with Go+// 1.7's Context.+//+// An emptyCtx is never canceled, has no values, and has no deadline. It is not+// struct{}, since vars of this type must have distinct addresses.+type emptyCtx int++func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {+ return+}++func (*emptyCtx) Done() <-chan struct{} {+ return nil+}++func (*emptyCtx) Err() error {+ return nil+}++func (*emptyCtx) Value(key interface{}) interface{} {+ return nil+}++func (e *emptyCtx) String() string {+ switch e {+ case backgroundCtx:+ return "aws.BackgroundContext"+ }+ return "unknown empty Context"+}++var (+ backgroundCtx = new(emptyCtx)+)diff --git a/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.gonew file mode 100644index 000000000..064f75c92--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go@@ -0,0 +1,9 @@+// +build go1.7++package aws++import "context"++var (+ backgroundCtx = context.Background()+)diff --git a/vendor/github.com/aws/aws-sdk-go/aws/convert_types.go b/vendor/github.com/aws/aws-sdk-go/aws/convert_types.gonew file mode 100644index 000000000..ff5d58e06--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/convert_types.go@@ -0,0 +1,387 @@+package aws++import "time"++// String returns a pointer to the string value passed in.+func String(v string) *string {+ return &v+}++// StringValue returns the value of the string pointer passed in or+// "" if the pointer is nil.+func StringValue(v *string) string {+ if v != nil {+ return *v+ }+ return ""+}++// StringSlice converts a slice of string values into a slice of+// string pointers+func StringSlice(src []string) []*string {+ dst := make([]*string, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// StringValueSlice converts a slice of string pointers into a slice of+// string values+func StringValueSlice(src []*string) []string {+ dst := make([]string, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// StringMap converts a string map of string values into a string+// map of string pointers+func StringMap(src map[string]string) map[string]*string {+ dst := make(map[string]*string)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// StringValueMap converts a string map of string pointers into a string+// map of string values+func StringValueMap(src map[string]*string) map[string]string {+ dst := make(map[string]string)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}++// Bool returns a pointer to the bool value passed in.+func Bool(v bool) *bool {+ return &v+}++// BoolValue returns the value of the bool pointer passed in or+// false if the pointer is nil.+func BoolValue(v *bool) bool {+ if v != nil {+ return *v+ }+ return false+}++// BoolSlice converts a slice of bool values into a slice of+// bool pointers+func BoolSlice(src []bool) []*bool {+ dst := make([]*bool, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// BoolValueSlice converts a slice of bool pointers into a slice of+// bool values+func BoolValueSlice(src []*bool) []bool {+ dst := make([]bool, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// BoolMap converts a string map of bool values into a string+// map of bool pointers+func BoolMap(src map[string]bool) map[string]*bool {+ dst := make(map[string]*bool)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// BoolValueMap converts a string map of bool pointers into a string+// map of bool values+func BoolValueMap(src map[string]*bool) map[string]bool {+ dst := make(map[string]bool)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}++// Int returns a pointer to the int value passed in.+func Int(v int) *int {+ return &v+}++// IntValue returns the value of the int pointer passed in or+// 0 if the pointer is nil.+func IntValue(v *int) int {+ if v != nil {+ return *v+ }+ return 0+}++// IntSlice converts a slice of int values into a slice of+// int pointers+func IntSlice(src []int) []*int {+ dst := make([]*int, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// IntValueSlice converts a slice of int pointers into a slice of+// int values+func IntValueSlice(src []*int) []int {+ dst := make([]int, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// IntMap converts a string map of int values into a string+// map of int pointers+func IntMap(src map[string]int) map[string]*int {+ dst := make(map[string]*int)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// IntValueMap converts a string map of int pointers into a string+// map of int values+func IntValueMap(src map[string]*int) map[string]int {+ dst := make(map[string]int)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}++// Int64 returns a pointer to the int64 value passed in.+func Int64(v int64) *int64 {+ return &v+}++// Int64Value returns the value of the int64 pointer passed in or+// 0 if the pointer is nil.+func Int64Value(v *int64) int64 {+ if v != nil {+ return *v+ }+ return 0+}++// Int64Slice converts a slice of int64 values into a slice of+// int64 pointers+func Int64Slice(src []int64) []*int64 {+ dst := make([]*int64, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// Int64ValueSlice converts a slice of int64 pointers into a slice of+// int64 values+func Int64ValueSlice(src []*int64) []int64 {+ dst := make([]int64, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// Int64Map converts a string map of int64 values into a string+// map of int64 pointers+func Int64Map(src map[string]int64) map[string]*int64 {+ dst := make(map[string]*int64)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// Int64ValueMap converts a string map of int64 pointers into a string+// map of int64 values+func Int64ValueMap(src map[string]*int64) map[string]int64 {+ dst := make(map[string]int64)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}++// Float64 returns a pointer to the float64 value passed in.+func Float64(v float64) *float64 {+ return &v+}++// Float64Value returns the value of the float64 pointer passed in or+// 0 if the pointer is nil.+func Float64Value(v *float64) float64 {+ if v != nil {+ return *v+ }+ return 0+}++// Float64Slice converts a slice of float64 values into a slice of+// float64 pointers+func Float64Slice(src []float64) []*float64 {+ dst := make([]*float64, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// Float64ValueSlice converts a slice of float64 pointers into a slice of+// float64 values+func Float64ValueSlice(src []*float64) []float64 {+ dst := make([]float64, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// Float64Map converts a string map of float64 values into a string+// map of float64 pointers+func Float64Map(src map[string]float64) map[string]*float64 {+ dst := make(map[string]*float64)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// Float64ValueMap converts a string map of float64 pointers into a string+// map of float64 values+func Float64ValueMap(src map[string]*float64) map[string]float64 {+ dst := make(map[string]float64)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}++// Time returns a pointer to the time.Time value passed in.+func Time(v time.Time) *time.Time {+ return &v+}++// TimeValue returns the value of the time.Time pointer passed in or+// time.Time{} if the pointer is nil.+func TimeValue(v *time.Time) time.Time {+ if v != nil {+ return *v+ }+ return time.Time{}+}++// SecondsTimeValue converts an int64 pointer to a time.Time value+// representing seconds since Epoch or time.Time{} if the pointer is nil.+func SecondsTimeValue(v *int64) time.Time {+ if v != nil {+ return time.Unix((*v / 1000), 0)+ }+ return time.Time{}+}++// MillisecondsTimeValue converts an int64 pointer to a time.Time value+// representing milliseconds sinch Epoch or time.Time{} if the pointer is nil.+func MillisecondsTimeValue(v *int64) time.Time {+ if v != nil {+ return time.Unix(0, (*v * 1000000))+ }+ return time.Time{}+}++// TimeUnixMilli returns a Unix timestamp in milliseconds from "January 1, 1970 UTC".+// The result is undefined if the Unix time cannot be represented by an int64.+// Which includes calling TimeUnixMilli on a zero Time is undefined.+//+// This utility is useful for service API's such as CloudWatch Logs which require+// their unix time values to be in milliseconds.+//+// See Go stdlib https://golang.org/pkg/time/#Time.UnixNano for more information.+func TimeUnixMilli(t time.Time) int64 {+ return t.UnixNano() / int64(time.Millisecond/time.Nanosecond)+}++// TimeSlice converts a slice of time.Time values into a slice of+// time.Time pointers+func TimeSlice(src []time.Time) []*time.Time {+ dst := make([]*time.Time, len(src))+ for i := 0; i < len(src); i++ {+ dst[i] = &(src[i])+ }+ return dst+}++// TimeValueSlice converts a slice of time.Time pointers into a slice of+// time.Time values+func TimeValueSlice(src []*time.Time) []time.Time {+ dst := make([]time.Time, len(src))+ for i := 0; i < len(src); i++ {+ if src[i] != nil {+ dst[i] = *(src[i])+ }+ }+ return dst+}++// TimeMap converts a string map of time.Time values into a string+// map of time.Time pointers+func TimeMap(src map[string]time.Time) map[string]*time.Time {+ dst := make(map[string]*time.Time)+ for k, val := range src {+ v := val+ dst[k] = &v+ }+ return dst+}++// TimeValueMap converts a string map of time.Time pointers into a string+// map of time.Time values+func TimeValueMap(src map[string]*time.Time) map[string]time.Time {+ dst := make(map[string]time.Time)+ for k, val := range src {+ if val != nil {+ dst[k] = *val+ }+ }+ return dst+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.gonew file mode 100644index 000000000..f8853d78a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go@@ -0,0 +1,228 @@+package corehandlers++import (+ "bytes"+ "fmt"+ "io/ioutil"+ "net/http"+ "net/url"+ "regexp"+ "strconv"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/request"+)++// Interface for matching types which also have a Len method.+type lener interface {+ Len() int+}++// BuildContentLengthHandler builds the content length of a request based on the body,+// or will use the HTTPRequest.Header's "Content-Length" if defined. If unable+// to determine request body length and no "Content-Length" was specified it will panic.+//+// The Content-Length will only be added to the request if the length of the body+// is greater than 0. If the body is empty or the current `Content-Length`+// header is <= 0, the header will also be stripped.+var BuildContentLengthHandler = request.NamedHandler{Name: "core.BuildContentLengthHandler", Fn: func(r *request.Request) {+ var length int64++ if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" {+ length, _ = strconv.ParseInt(slength, 10, 64)+ } else {+ if r.Body != nil {+ var err error+ length, err = aws.SeekerLen(r.Body)+ if err != nil {+ r.Error = awserr.New(request.ErrCodeSerialization, "failed to get request body's length", err)+ return+ }+ }+ }++ if length > 0 {+ r.HTTPRequest.ContentLength = length+ r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))+ } else {+ r.HTTPRequest.ContentLength = 0+ r.HTTPRequest.Header.Del("Content-Length")+ }+}}++var reStatusCode = regexp.MustCompile(`^(\d{3})`)++// ValidateReqSigHandler is a request handler to ensure that the request's+// signature doesn't expire before it is sent. This can happen when a request+// is built and signed significantly before it is sent. Or significant delays+// occur when retrying requests that would cause the signature to expire.+var ValidateReqSigHandler = request.NamedHandler{+ Name: "core.ValidateReqSigHandler",+ Fn: func(r *request.Request) {+ // Unsigned requests are not signed+ if r.Config.Credentials == credentials.AnonymousCredentials {+ return+ }++ signedTime := r.Time+ if !r.LastSignedAt.IsZero() {+ signedTime = r.LastSignedAt+ }++ // 5 minutes to allow for some clock skew/delays in transmission.+ // Would be improved with aws/aws-sdk-go#423+ if signedTime.Add(5 * time.Minute).After(time.Now()) {+ return+ }++ fmt.Println("request expired, resigning")+ r.Sign()+ },+}++// SendHandler is a request handler to send service request using HTTP client.+var SendHandler = request.NamedHandler{+ Name: "core.SendHandler",+ Fn: func(r *request.Request) {+ sender := sendFollowRedirects+ if r.DisableFollowRedirects {+ sender = sendWithoutFollowRedirects+ }++ if request.NoBody == r.HTTPRequest.Body {+ // Strip off the request body if the NoBody reader was used as a+ // place holder for a request body. This prevents the SDK from+ // making requests with a request body when it would be invalid+ // to do so.+ //+ // Use a shallow copy of the http.Request to ensure the race condition+ // of transport on Body will not trigger+ reqOrig, reqCopy := r.HTTPRequest, *r.HTTPRequest+ reqCopy.Body = nil+ r.HTTPRequest = &reqCopy+ defer func() {+ r.HTTPRequest = reqOrig+ }()+ }++ var err error+ r.HTTPResponse, err = sender(r)+ if err != nil {+ handleSendError(r, err)+ }+ },+}++func sendFollowRedirects(r *request.Request) (*http.Response, error) {+ return r.Config.HTTPClient.Do(r.HTTPRequest)+}++func sendWithoutFollowRedirects(r *request.Request) (*http.Response, error) {+ transport := r.Config.HTTPClient.Transport+ if transport == nil {+ transport = http.DefaultTransport+ }++ return transport.RoundTrip(r.HTTPRequest)+}++func handleSendError(r *request.Request, err error) {+ // Prevent leaking if an HTTPResponse was returned. Clean up+ // the body.+ if r.HTTPResponse != nil {+ r.HTTPResponse.Body.Close()+ }+ // Capture the case where url.Error is returned for error processing+ // response. e.g. 301 without location header comes back as string+ // error and r.HTTPResponse is nil. Other URL redirect errors will+ // comeback in a similar method.+ if e, ok := err.(*url.Error); ok && e.Err != nil {+ if s := reStatusCode.FindStringSubmatch(e.Err.Error()); s != nil {+ code, _ := strconv.ParseInt(s[1], 10, 64)+ r.HTTPResponse = &http.Response{+ StatusCode: int(code),+ Status: http.StatusText(int(code)),+ Body: ioutil.NopCloser(bytes.NewReader([]byte{})),+ }+ return+ }+ }+ if r.HTTPResponse == nil {+ // Add a dummy request response object to ensure the HTTPResponse+ // value is consistent.+ r.HTTPResponse = &http.Response{+ StatusCode: int(0),+ Status: http.StatusText(int(0)),+ Body: ioutil.NopCloser(bytes.NewReader([]byte{})),+ }+ }+ // Catch all other request errors.+ r.Error = awserr.New("RequestError", "send request failed", err)+ r.Retryable = aws.Bool(true) // network errors are retryable++ // Override the error with a context canceled error, if that was canceled.+ ctx := r.Context()+ select {+ case <-ctx.Done():+ r.Error = awserr.New(request.CanceledErrorCode,+ "request context canceled", ctx.Err())+ r.Retryable = aws.Bool(false)+ default:+ }+}++// ValidateResponseHandler is a request handler to validate service response.+var ValidateResponseHandler = request.NamedHandler{Name: "core.ValidateResponseHandler", Fn: func(r *request.Request) {+ if r.HTTPResponse.StatusCode == 0 || r.HTTPResponse.StatusCode >= 300 {+ // this may be replaced by an UnmarshalError handler+ r.Error = awserr.New("UnknownError", "unknown error", nil)+ }+}}++// AfterRetryHandler performs final checks to determine if the request should+// be retried and how long to delay.+var AfterRetryHandler = request.NamedHandler{Name: "core.AfterRetryHandler", Fn: func(r *request.Request) {+ // If one of the other handlers already set the retry state+ // we don't want to override it based on the service's state+ if r.Retryable == nil || aws.BoolValue(r.Config.EnforceShouldRetryCheck) {+ r.Retryable = aws.Bool(r.ShouldRetry(r))+ }++ if r.WillRetry() {+ r.RetryDelay = r.RetryRules(r)++ if sleepFn := r.Config.SleepDelay; sleepFn != nil {+ // Support SleepDelay for backwards compatibility and testing+ sleepFn(r.RetryDelay)+ } else if err := aws.SleepWithContext(r.Context(), r.RetryDelay); err != nil {+ r.Error = awserr.New(request.CanceledErrorCode,+ "request context canceled", err)+ r.Retryable = aws.Bool(false)+ return+ }++ // when the expired token exception occurs the credentials+ // need to be expired locally so that the next request to+ // get credentials will trigger a credentials refresh.+ if r.IsErrorExpired() {+ r.Config.Credentials.Expire()+ }++ r.RetryCount+++ r.Error = nil+ }+}}++// ValidateEndpointHandler is a request handler to validate a request had the+// appropriate Region and Endpoint set. Will set r.Error if the endpoint or+// region is not valid.+var ValidateEndpointHandler = request.NamedHandler{Name: "core.ValidateEndpointHandler", Fn: func(r *request.Request) {+ if r.ClientInfo.SigningRegion == "" && aws.StringValue(r.Config.Region) == "" {+ r.Error = aws.ErrMissingRegion+ } else if r.ClientInfo.Endpoint == "" {+ r.Error = aws.ErrMissingEndpoint+ }+}}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.gonew file mode 100644index 000000000..7d50b1557--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go@@ -0,0 +1,17 @@+package corehandlers++import "github.com/aws/aws-sdk-go/aws/request"++// ValidateParametersHandler is a request handler to validate the input parameters.+// Validating parameters only has meaning if done prior to the request being sent.+var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {+ if !r.ParamsFilled() {+ return+ }++ if v, ok := r.Params.(request.Validator); ok {+ if err := v.Validate(); err != nil {+ r.Error = err+ }+ }+}}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.gonew file mode 100644index 000000000..a15f496bc--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.go@@ -0,0 +1,37 @@+package corehandlers++import (+ "os"+ "runtime"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/request"+)++// SDKVersionUserAgentHandler is a request handler for adding the SDK Version+// to the user agent.+var SDKVersionUserAgentHandler = request.NamedHandler{+ Name: "core.SDKVersionUserAgentHandler",+ Fn: request.MakeAddToUserAgentHandler(aws.SDKName, aws.SDKVersion,+ runtime.Version(), runtime.GOOS, runtime.GOARCH),+}++const execEnvVar = `AWS_EXECUTION_ENV`+const execEnvUAKey = `exec_env`++// AddHostExecEnvUserAgentHander is a request handler appending the SDK's+// execution environment to the user agent.+//+// If the environment variable AWS_EXECUTION_ENV is set, its value will be+// appended to the user agent string.+var AddHostExecEnvUserAgentHander = request.NamedHandler{+ Name: "core.AddHostExecEnvUserAgentHander",+ Fn: func(r *request.Request) {+ v := os.Getenv(execEnvVar)+ if len(v) == 0 {+ return+ }++ request.AddToUserAgent(r, execEnvUAKey+"/"+v)+ },+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.gonew file mode 100644index 000000000..3ad1e798d--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/chain_provider.go@@ -0,0 +1,100 @@+package credentials++import (+ "github.com/aws/aws-sdk-go/aws/awserr"+)++var (+ // ErrNoValidProvidersFoundInChain Is returned when there are no valid+ // providers in the ChainProvider.+ //+ // This has been deprecated. For verbose error messaging set+ // aws.Config.CredentialsChainVerboseErrors to true.+ ErrNoValidProvidersFoundInChain = awserr.New("NoCredentialProviders",+ `no valid providers in chain. Deprecated.+ For verbose messaging see aws.Config.CredentialsChainVerboseErrors`,+ nil)+)++// A ChainProvider will search for a provider which returns credentials+// and cache that provider until Retrieve is called again.+//+// The ChainProvider provides a way of chaining multiple providers together+// which will pick the first available using priority order of the Providers+// in the list.+//+// If none of the Providers retrieve valid credentials Value, ChainProvider's+// Retrieve() will return the error ErrNoValidProvidersFoundInChain.+//+// If a Provider is found which returns valid credentials Value ChainProvider+// will cache that Provider for all calls to IsExpired(), until Retrieve is+// called again.+//+// Example of ChainProvider to be used with an EnvProvider and EC2RoleProvider.+// In this example EnvProvider will first check if any credentials are available+// via the environment variables. If there are none ChainProvider will check+// the next Provider in the list, EC2RoleProvider in this case. If EC2RoleProvider+// does not return any credentials ChainProvider will return the error+// ErrNoValidProvidersFoundInChain+//+// creds := credentials.NewChainCredentials(+// []credentials.Provider{+// &credentials.EnvProvider{},+// &ec2rolecreds.EC2RoleProvider{+// Client: ec2metadata.New(sess),+// },+// })+//+// // Usage of ChainCredentials with aws.Config+// svc := ec2.New(session.Must(session.NewSession(&aws.Config{+// Credentials: creds,+// })))+//+type ChainProvider struct {+ Providers []Provider+ curr Provider+ VerboseErrors bool+}++// NewChainCredentials returns a pointer to a new Credentials object+// wrapping a chain of providers.+func NewChainCredentials(providers []Provider) *Credentials {+ return NewCredentials(&ChainProvider{+ Providers: append([]Provider{}, providers...),+ })+}++// Retrieve returns the credentials value or error if no provider returned+// without error.+//+// If a provider is found it will be cached and any calls to IsExpired()+// will return the expired state of the cached provider.+func (c *ChainProvider) Retrieve() (Value, error) {+ var errs []error+ for _, p := range c.Providers {+ creds, err := p.Retrieve()+ if err == nil {+ c.curr = p+ return creds, nil+ }+ errs = append(errs, err)+ }+ c.curr = nil++ var err error+ err = ErrNoValidProvidersFoundInChain+ if c.VerboseErrors {+ err = awserr.NewBatchError("NoCredentialProviders", "no valid providers in chain", errs)+ }+ return Value{}, err+}++// IsExpired will returned the expired state of the currently cached provider+// if there is one. If there is no current provider, true will be returned.+func (c *ChainProvider) IsExpired() bool {+ if c.curr != nil {+ return c.curr.IsExpired()+ }++ return true+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.gonew file mode 100644index 000000000..dc82f4c3c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/credentials.go@@ -0,0 +1,257 @@+// Package credentials provides credential retrieval and management+//+// The Credentials is the primary method of getting access to and managing+// credentials Values. Using dependency injection retrieval of the credential+// values is handled by a object which satisfies the Provider interface.+//+// By default the Credentials.Get() will cache the successful result of a+// Provider's Retrieve() until Provider.IsExpired() returns true. At which+// point Credentials will call Provider's Retrieve() to get new credential Value.+//+// The Provider is responsible for determining when credentials Value have expired.+// It is also important to note that Credentials will always call Retrieve the+// first time Credentials.Get() is called.+//+// Example of using the environment variable credentials.+//+// creds := credentials.NewEnvCredentials()+//+// // Retrieve the credentials value+// credValue, err := creds.Get()+// if err != nil {+// // handle error+// }+//+// Example of forcing credentials to expire and be refreshed on the next Get().+// This may be helpful to proactively expire credentials and refresh them sooner+// than they would naturally expire on their own.+//+// creds := credentials.NewCredentials(&ec2rolecreds.EC2RoleProvider{})+// creds.Expire()+// credsValue, err := creds.Get()+// // New credentials will be retrieved instead of from cache.+//+//+// Custom Provider+//+// Each Provider built into this package also provides a helper method to generate+// a Credentials pointer setup with the provider. To use a custom Provider just+// create a type which satisfies the Provider interface and pass it to the+// NewCredentials method.+//+// type MyProvider struct{}+// func (m *MyProvider) Retrieve() (Value, error) {...}+// func (m *MyProvider) IsExpired() bool {...}+//+// creds := credentials.NewCredentials(&MyProvider{})+// credValue, err := creds.Get()+//+package credentials++import (+ "sync"+ "time"+)++// AnonymousCredentials is an empty Credential object that can be used as+// dummy placeholder credentials for requests that do not need signed.+//+// This Credentials can be used to configure a service to not sign requests+// when making service API calls. For example, when accessing public+// s3 buckets.+//+// svc := s3.New(session.Must(session.NewSession(&aws.Config{+// Credentials: credentials.AnonymousCredentials,+// })))+// // Access public S3 buckets.+var AnonymousCredentials = NewStaticCredentials("", "", "")++// A Value is the AWS credentials value for individual credential fields.+type Value struct {+ // AWS Access key ID+ AccessKeyID string++ // AWS Secret Access Key+ SecretAccessKey string++ // AWS Session Token+ SessionToken string++ // Provider used to get credentials+ ProviderName string+}++// A Provider is the interface for any component which will provide credentials+// Value. A provider is required to manage its own Expired state, and what to+// be expired means.+//+// The Provider should not need to implement its own mutexes, because+// that will be managed by Credentials.+type Provider interface {+ // Retrieve returns nil if it successfully retrieved the value.+ // Error is returned if the value were not obtainable, or empty.+ Retrieve() (Value, error)++ // IsExpired returns if the credentials are no longer valid, and need+ // to be retrieved.+ IsExpired() bool+}++// An ErrorProvider is a stub credentials provider that always returns an error+// this is used by the SDK when construction a known provider is not possible+// due to an error.+type ErrorProvider struct {+ // The error to be returned from Retrieve+ Err error++ // The provider name to set on the Retrieved returned Value+ ProviderName string+}++// Retrieve will always return the error that the ErrorProvider was created with.+func (p ErrorProvider) Retrieve() (Value, error) {+ return Value{ProviderName: p.ProviderName}, p.Err+}++// IsExpired will always return not expired.+func (p ErrorProvider) IsExpired() bool {+ return false+}++// A Expiry provides shared expiration logic to be used by credentials+// providers to implement expiry functionality.+//+// The best method to use this struct is as an anonymous field within the+// provider's struct.+//+// Example:+// type EC2RoleProvider struct {+// Expiry+// ...+// }+type Expiry struct {+ // The date/time when to expire on+ expiration time.Time++ // If set will be used by IsExpired to determine the current time.+ // Defaults to time.Now if CurrentTime is not set. Available for testing+ // to be able to mock out the current time.+ CurrentTime func() time.Time+}++// SetExpiration sets the expiration IsExpired will check when called.+//+// If window is greater than 0 the expiration time will be reduced by the+// window value.+//+// Using a window is helpful to trigger credentials to expire sooner than+// the expiration time given to ensure no requests are made with expired+// tokens.+func (e *Expiry) SetExpiration(expiration time.Time, window time.Duration) {+ e.expiration = expiration+ if window > 0 {+ e.expiration = e.expiration.Add(-window)+ }+}++// IsExpired returns if the credentials are expired.+func (e *Expiry) IsExpired() bool {+ curTime := e.CurrentTime+ if curTime == nil {+ curTime = time.Now+ }+ return e.expiration.Before(curTime())+}++// A Credentials provides concurrency safe retrieval of AWS credentials Value.+// Credentials will cache the credentials value until they expire. Once the value+// expires the next Get will attempt to retrieve valid credentials.+//+// Credentials is safe to use across multiple goroutines and will manage the+// synchronous state so the Providers do not need to implement their own+// synchronization.+//+// The first Credentials.Get() will always call Provider.Retrieve() to get the+// first instance of the credentials Value. All calls to Get() after that+// will return the cached credentials Value until IsExpired() returns true.+type Credentials struct {+ creds Value+ forceRefresh bool++ m sync.RWMutex++ provider Provider+}++// NewCredentials returns a pointer to a new Credentials with the provider set.+func NewCredentials(provider Provider) *Credentials {+ return &Credentials{+ provider: provider,+ forceRefresh: true,+ }+}++// Get returns the credentials value, or error if the credentials Value failed+// to be retrieved.+//+// Will return the cached credentials Value if it has not expired. If the+// credentials Value has expired the Provider's Retrieve() will be called+// to refresh the credentials.+//+// If Credentials.Expire() was called the credentials Value will be force+// expired, and the next call to Get() will cause them to be refreshed.+func (c *Credentials) Get() (Value, error) {+ // Check the cached credentials first with just the read lock.+ c.m.RLock()+ if !c.isExpired() {+ creds := c.creds+ c.m.RUnlock()+ return creds, nil+ }+ c.m.RUnlock()++ // Credentials are expired need to retrieve the credentials taking the full+ // lock.+ c.m.Lock()+ defer c.m.Unlock()++ if c.isExpired() {+ creds, err := c.provider.Retrieve()+ if err != nil {+ return Value{}, err+ }+ c.creds = creds+ c.forceRefresh = false+ }++ return c.creds, nil+}++// Expire expires the credentials and forces them to be retrieved on the+// next call to Get().+//+// This will override the Provider's expired state, and force Credentials+// to call the Provider's Retrieve().+func (c *Credentials) Expire() {+ c.m.Lock()+ defer c.m.Unlock()++ c.forceRefresh = true+}++// IsExpired returns if the credentials are no longer valid, and need+// to be retrieved.+//+// If the Credentials were forced to be expired with Expire() this will+// reflect that override.+func (c *Credentials) IsExpired() bool {+ c.m.RLock()+ defer c.m.RUnlock()++ return c.isExpired()+}++// isExpired helper method wrapping the definition of expired credentials.+func (c *Credentials) isExpired() bool {+ return c.forceRefresh || c.provider.IsExpired()+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.gonew file mode 100644index 000000000..0ed791be6--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider.go@@ -0,0 +1,178 @@+package ec2rolecreds++import (+ "bufio"+ "encoding/json"+ "fmt"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/ec2metadata"+ "github.com/aws/aws-sdk-go/internal/sdkuri"+)++// ProviderName provides a name of EC2Role provider+const ProviderName = "EC2RoleProvider"++// A EC2RoleProvider retrieves credentials from the EC2 service, and keeps track if+// those credentials are expired.+//+// Example how to configure the EC2RoleProvider with custom http Client, Endpoint+// or ExpiryWindow+//+// p := &ec2rolecreds.EC2RoleProvider{+// // Pass in a custom timeout to be used when requesting+// // IAM EC2 Role credentials.+// Client: ec2metadata.New(sess, aws.Config{+// HTTPClient: &http.Client{Timeout: 10 * time.Second},+// }),+//+// // Do not use early expiry of credentials. If a non zero value is+// // specified the credentials will be expired early+// ExpiryWindow: 0,+// }+type EC2RoleProvider struct {+ credentials.Expiry++ // Required EC2Metadata client to use when connecting to EC2 metadata service.+ Client *ec2metadata.EC2Metadata++ // ExpiryWindow will allow the credentials to trigger refreshing prior to+ // the credentials actually expiring. This is beneficial so race conditions+ // with expiring credentials do not cause request to fail unexpectedly+ // due to ExpiredTokenException exceptions.+ //+ // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true+ // 10 seconds before the credentials are actually expired.+ //+ // If ExpiryWindow is 0 or less it will be ignored.+ ExpiryWindow time.Duration+}++// NewCredentials returns a pointer to a new Credentials object wrapping+// the EC2RoleProvider. Takes a ConfigProvider to create a EC2Metadata client.+// The ConfigProvider is satisfied by the session.Session type.+func NewCredentials(c client.ConfigProvider, options ...func(*EC2RoleProvider)) *credentials.Credentials {+ p := &EC2RoleProvider{+ Client: ec2metadata.New(c),+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++// NewCredentialsWithClient returns a pointer to a new Credentials object wrapping+// the EC2RoleProvider. Takes a EC2Metadata client to use when connecting to EC2+// metadata service.+func NewCredentialsWithClient(client *ec2metadata.EC2Metadata, options ...func(*EC2RoleProvider)) *credentials.Credentials {+ p := &EC2RoleProvider{+ Client: client,+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++// Retrieve retrieves credentials from the EC2 service.+// Error will be returned if the request fails, or unable to extract+// the desired credentials.+func (m *EC2RoleProvider) Retrieve() (credentials.Value, error) {+ credsList, err := requestCredList(m.Client)+ if err != nil {+ return credentials.Value{ProviderName: ProviderName}, err+ }++ if len(credsList) == 0 {+ return credentials.Value{ProviderName: ProviderName}, awserr.New("EmptyEC2RoleList", "empty EC2 Role list", nil)+ }+ credsName := credsList[0]++ roleCreds, err := requestCred(m.Client, credsName)+ if err != nil {+ return credentials.Value{ProviderName: ProviderName}, err+ }++ m.SetExpiration(roleCreds.Expiration, m.ExpiryWindow)++ return credentials.Value{+ AccessKeyID: roleCreds.AccessKeyID,+ SecretAccessKey: roleCreds.SecretAccessKey,+ SessionToken: roleCreds.Token,+ ProviderName: ProviderName,+ }, nil+}++// A ec2RoleCredRespBody provides the shape for unmarshaling credential+// request responses.+type ec2RoleCredRespBody struct {+ // Success State+ Expiration time.Time+ AccessKeyID string+ SecretAccessKey string+ Token string++ // Error state+ Code string+ Message string+}++const iamSecurityCredsPath = "iam/security-credentials/"++// requestCredList requests a list of credentials from the EC2 service.+// If there are no credentials, or there is an error making or receiving the request+func requestCredList(client *ec2metadata.EC2Metadata) ([]string, error) {+ resp, err := client.GetMetadata(iamSecurityCredsPath)+ if err != nil {+ return nil, awserr.New("EC2RoleRequestError", "no EC2 instance role found", err)+ }++ credsList := []string{}+ s := bufio.NewScanner(strings.NewReader(resp))+ for s.Scan() {+ credsList = append(credsList, s.Text())+ }++ if err := s.Err(); err != nil {+ return nil, awserr.New("SerializationError", "failed to read EC2 instance role from metadata service", err)+ }++ return credsList, nil+}++// requestCred requests the credentials for a specific credentials from the EC2 service.+//+// If the credentials cannot be found, or there is an error reading the response+// and error will be returned.+func requestCred(client *ec2metadata.EC2Metadata, credsName string) (ec2RoleCredRespBody, error) {+ resp, err := client.GetMetadata(sdkuri.PathJoin(iamSecurityCredsPath, credsName))+ if err != nil {+ return ec2RoleCredRespBody{},+ awserr.New("EC2RoleRequestError",+ fmt.Sprintf("failed to get %s EC2 instance role credentials", credsName),+ err)+ }++ respCreds := ec2RoleCredRespBody{}+ if err := json.NewDecoder(strings.NewReader(resp)).Decode(&respCreds); err != nil {+ return ec2RoleCredRespBody{},+ awserr.New("SerializationError",+ fmt.Sprintf("failed to decode %s EC2 instance role credentials", credsName),+ err)+ }++ if respCreds.Code != "Success" {+ // If an error code was returned something failed requesting the role.+ return ec2RoleCredRespBody{}, awserr.New(respCreds.Code, respCreds.Message, nil)+ }++ return respCreds, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.gonew file mode 100644index 000000000..ace513138--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/endpointcreds/provider.go@@ -0,0 +1,198 @@+// Package endpointcreds provides support for retrieving credentials from an+// arbitrary HTTP endpoint.+//+// The credentials endpoint Provider can receive both static and refreshable+// credentials that will expire. Credentials are static when an "Expiration"+// value is not provided in the endpoint's response.+//+// Static credentials will never expire once they have been retrieved. The format+// of the static credentials response:+// {+// "AccessKeyId" : "MUA...",+// "SecretAccessKey" : "/7PC5om....",+// }+//+// Refreshable credentials will expire within the "ExpiryWindow" of the Expiration+// value in the response. The format of the refreshable credentials response:+// {+// "AccessKeyId" : "MUA...",+// "SecretAccessKey" : "/7PC5om....",+// "Token" : "AQoDY....=",+// "Expiration" : "2016-02-25T06:03:31Z"+// }+//+// Errors should be returned in the following format and only returned with 400+// or 500 HTTP status codes.+// {+// "code": "ErrorCode",+// "message": "Helpful error message."+// }+package endpointcreds++import (+ "encoding/json"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/request"+)++// ProviderName is the name of the credentials provider.+const ProviderName = `CredentialsEndpointProvider`++// Provider satisfies the credentials.Provider interface, and is a client to+// retrieve credentials from an arbitrary endpoint.+type Provider struct {+ staticCreds bool+ credentials.Expiry++ // Requires a AWS Client to make HTTP requests to the endpoint with.+ // the Endpoint the request will be made to is provided by the aws.Config's+ // Endpoint value.+ Client *client.Client++ // ExpiryWindow will allow the credentials to trigger refreshing prior to+ // the credentials actually expiring. This is beneficial so race conditions+ // with expiring credentials do not cause request to fail unexpectedly+ // due to ExpiredTokenException exceptions.+ //+ // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true+ // 10 seconds before the credentials are actually expired.+ //+ // If ExpiryWindow is 0 or less it will be ignored.+ ExpiryWindow time.Duration++ // Optional authorization token value if set will be used as the value of+ // the Authorization header of the endpoint credential request.+ AuthorizationToken string+}++// NewProviderClient returns a credentials Provider for retrieving AWS credentials+// from arbitrary endpoint.+func NewProviderClient(cfg aws.Config, handlers request.Handlers, endpoint string, options ...func(*Provider)) credentials.Provider {+ p := &Provider{+ Client: client.New(+ cfg,+ metadata.ClientInfo{+ ServiceName: "CredentialsEndpoint",+ Endpoint: endpoint,+ },+ handlers,+ ),+ }++ p.Client.Handlers.Unmarshal.PushBack(unmarshalHandler)+ p.Client.Handlers.UnmarshalError.PushBack(unmarshalError)+ p.Client.Handlers.Validate.Clear()+ p.Client.Handlers.Validate.PushBack(validateEndpointHandler)++ for _, option := range options {+ option(p)+ }++ return p+}++// NewCredentialsClient returns a Credentials wrapper for retrieving credentials+// from an arbitrary endpoint concurrently. The client will request the+func NewCredentialsClient(cfg aws.Config, handlers request.Handlers, endpoint string, options ...func(*Provider)) *credentials.Credentials {+ return credentials.NewCredentials(NewProviderClient(cfg, handlers, endpoint, options...))+}++// IsExpired returns true if the credentials retrieved are expired, or not yet+// retrieved.+func (p *Provider) IsExpired() bool {+ if p.staticCreds {+ return false+ }+ return p.Expiry.IsExpired()+}++// Retrieve will attempt to request the credentials from the endpoint the Provider+// was configured for. And error will be returned if the retrieval fails.+func (p *Provider) Retrieve() (credentials.Value, error) {+ resp, err := p.getCredentials()+ if err != nil {+ return credentials.Value{ProviderName: ProviderName},+ awserr.New("CredentialsEndpointError", "failed to load credentials", err)+ }++ if resp.Expiration != nil {+ p.SetExpiration(*resp.Expiration, p.ExpiryWindow)+ } else {+ p.staticCreds = true+ }++ return credentials.Value{+ AccessKeyID: resp.AccessKeyID,+ SecretAccessKey: resp.SecretAccessKey,+ SessionToken: resp.Token,+ ProviderName: ProviderName,+ }, nil+}++type getCredentialsOutput struct {+ Expiration *time.Time+ AccessKeyID string+ SecretAccessKey string+ Token string+}++type errorOutput struct {+ Code string `json:"code"`+ Message string `json:"message"`+}++func (p *Provider) getCredentials() (*getCredentialsOutput, error) {+ op := &request.Operation{+ Name: "GetCredentials",+ HTTPMethod: "GET",+ }++ out := &getCredentialsOutput{}+ req := p.Client.NewRequest(op, nil, out)+ req.HTTPRequest.Header.Set("Accept", "application/json")+ if authToken := p.AuthorizationToken; len(authToken) != 0 {+ req.HTTPRequest.Header.Set("Authorization", authToken)+ }++ return out, req.Send()+}++func validateEndpointHandler(r *request.Request) {+ if len(r.ClientInfo.Endpoint) == 0 {+ r.Error = aws.ErrMissingEndpoint+ }+}++func unmarshalHandler(r *request.Request) {+ defer r.HTTPResponse.Body.Close()++ out := r.Data.(*getCredentialsOutput)+ if err := json.NewDecoder(r.HTTPResponse.Body).Decode(&out); err != nil {+ r.Error = awserr.New("SerializationError",+ "failed to decode endpoint credentials",+ err,+ )+ }+}++func unmarshalError(r *request.Request) {+ defer r.HTTPResponse.Body.Close()++ var errOut errorOutput+ if err := json.NewDecoder(r.HTTPResponse.Body).Decode(&errOut); err != nil {+ r.Error = awserr.New("SerializationError",+ "failed to decode endpoint credentials",+ err,+ )+ }++ // Response body format is not consistent between metadata endpoints.+ // Grab the error message as a string and include that as the source error+ r.Error = awserr.New(errOut.Code, errOut.Message, nil)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.gonew file mode 100644index 000000000..54c5cf733--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/env_provider.go@@ -0,0 +1,74 @@+package credentials++import (+ "os"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++// EnvProviderName provides a name of Env provider+const EnvProviderName = "EnvProvider"++var (+ // ErrAccessKeyIDNotFound is returned when the AWS Access Key ID can't be+ // found in the process's environment.+ ErrAccessKeyIDNotFound = awserr.New("EnvAccessKeyNotFound", "AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY not found in environment", nil)++ // ErrSecretAccessKeyNotFound is returned when the AWS Secret Access Key+ // can't be found in the process's environment.+ ErrSecretAccessKeyNotFound = awserr.New("EnvSecretNotFound", "AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY not found in environment", nil)+)++// A EnvProvider retrieves credentials from the environment variables of the+// running process. Environment credentials never expire.+//+// Environment variables used:+//+// * Access Key ID: AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY+//+// * Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY+type EnvProvider struct {+ retrieved bool+}++// NewEnvCredentials returns a pointer to a new Credentials object+// wrapping the environment variable provider.+func NewEnvCredentials() *Credentials {+ return NewCredentials(&EnvProvider{})+}++// Retrieve retrieves the keys from the environment.+func (e *EnvProvider) Retrieve() (Value, error) {+ e.retrieved = false++ id := os.Getenv("AWS_ACCESS_KEY_ID")+ if id == "" {+ id = os.Getenv("AWS_ACCESS_KEY")+ }++ secret := os.Getenv("AWS_SECRET_ACCESS_KEY")+ if secret == "" {+ secret = os.Getenv("AWS_SECRET_KEY")+ }++ if id == "" {+ return Value{ProviderName: EnvProviderName}, ErrAccessKeyIDNotFound+ }++ if secret == "" {+ return Value{ProviderName: EnvProviderName}, ErrSecretAccessKeyNotFound+ }++ e.retrieved = true+ return Value{+ AccessKeyID: id,+ SecretAccessKey: secret,+ SessionToken: os.Getenv("AWS_SESSION_TOKEN"),+ ProviderName: EnvProviderName,+ }, nil+}++// IsExpired returns if the credentials have been retrieved.+func (e *EnvProvider) IsExpired() bool {+ return !e.retrieved+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini b/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ininew file mode 100644index 000000000..7fc91d9d2--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini@@ -0,0 +1,12 @@+[default]+aws_access_key_id = accessKey+aws_secret_access_key = secret+aws_session_token = token++[no_token]+aws_access_key_id = accessKey+aws_secret_access_key = secret++[with_colon]+aws_access_key_id: accessKey+aws_secret_access_key: secretdiff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/processcreds/provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/processcreds/provider.gonew file mode 100644index 000000000..1980c8c14--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/processcreds/provider.go@@ -0,0 +1,425 @@+/*+Package processcreds is a credential Provider to retrieve `credential_process`+credentials.++WARNING: The following describes a method of sourcing credentials from an external+process. This can potentially be dangerous, so proceed with caution. Other+credential providers should be preferred if at all possible. If using this+option, you should make sure that the config file is as locked down as possible+using security best practices for your operating system.++You can use credentials from a `credential_process` in a variety of ways.++One way is to setup your shared config file, located in the default+location, with the `credential_process` key and the command you want to be+called. You also need to set the AWS_SDK_LOAD_CONFIG environment variable+(e.g., `export AWS_SDK_LOAD_CONFIG=1`) to use the shared config file.++ [default]+ credential_process = /command/to/call++Creating a new session will use the credential process to retrieve credentials.+NOTE: If there are credentials in the profile you are using, the credential+process will not be used.++ // Initialize a session to load credentials.+ sess, _ := session.NewSession(&aws.Config{+ Region: aws.String("us-east-1")},+ )++ // Create S3 service client to use the credentials.+ svc := s3.New(sess)++Another way to use the `credential_process` method is by using+`credentials.NewCredentials()` and providing a command to be executed to+retrieve credentials:++ // Create credentials using the ProcessProvider.+ creds := processcreds.NewCredentials("/path/to/command")++ // Create service client value configured for credentials.+ svc := s3.New(sess, &aws.Config{Credentials: creds})++You can set a non-default timeout for the `credential_process` with another+constructor, `credentials.NewCredentialsTimeout()`, providing the timeout. To+set a one minute timeout:++ // Create credentials using the ProcessProvider.+ creds := processcreds.NewCredentialsTimeout(+ "/path/to/command",+ time.Duration(500) * time.Millisecond)++If you need more control, you can set any configurable options in the+credentials using one or more option functions. For example, you can set a two+minute timeout, a credential duration of 60 minutes, and a maximum stdout+buffer size of 2k.++ creds := processcreds.NewCredentials(+ "/path/to/command",+ func(opt *ProcessProvider) {+ opt.Timeout = time.Duration(2) * time.Minute+ opt.Duration = time.Duration(60) * time.Minute+ opt.MaxBufSize = 2048+ })++You can also use your own `exec.Cmd`:++ // Create an exec.Cmd+ myCommand := exec.Command("/path/to/command")++ // Create credentials using your exec.Cmd and custom timeout+ creds := processcreds.NewCredentialsCommand(+ myCommand,+ func(opt *processcreds.ProcessProvider) {+ opt.Timeout = time.Duration(1) * time.Second+ })+*/+package processcreds++import (+ "bytes"+ "encoding/json"+ "fmt"+ "io"+ "io/ioutil"+ "os"+ "os/exec"+ "runtime"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/credentials"+)++const (+ // ProviderName is the name this credentials provider will label any+ // returned credentials Value with.+ ProviderName = `ProcessProvider`++ // ErrCodeProcessProviderParse error parsing process output+ ErrCodeProcessProviderParse = "ProcessProviderParseError"++ // ErrCodeProcessProviderVersion version error in output+ ErrCodeProcessProviderVersion = "ProcessProviderVersionError"++ // ErrCodeProcessProviderRequired required attribute missing in output+ ErrCodeProcessProviderRequired = "ProcessProviderRequiredError"++ // ErrCodeProcessProviderExecution execution of command failed+ ErrCodeProcessProviderExecution = "ProcessProviderExecutionError"++ // errMsgProcessProviderTimeout process took longer than allowed+ errMsgProcessProviderTimeout = "credential process timed out"++ // errMsgProcessProviderProcess process error+ errMsgProcessProviderProcess = "error in credential_process"++ // errMsgProcessProviderParse problem parsing output+ errMsgProcessProviderParse = "parse failed of credential_process output"++ // errMsgProcessProviderVersion version error in output+ errMsgProcessProviderVersion = "wrong version in process output (not 1)"++ // errMsgProcessProviderMissKey missing access key id in output+ errMsgProcessProviderMissKey = "missing AccessKeyId in process output"++ // errMsgProcessProviderMissSecret missing secret acess key in output+ errMsgProcessProviderMissSecret = "missing SecretAccessKey in process output"++ // errMsgProcessProviderPrepareCmd prepare of command failed+ errMsgProcessProviderPrepareCmd = "failed to prepare command"++ // errMsgProcessProviderEmptyCmd command must not be empty+ errMsgProcessProviderEmptyCmd = "command must not be empty"++ // errMsgProcessProviderPipe failed to initialize pipe+ errMsgProcessProviderPipe = "failed to initialize pipe"++ // DefaultDuration is the default amount of time in minutes that the+ // credentials will be valid for.+ DefaultDuration = time.Duration(15) * time.Minute++ // DefaultBufSize limits buffer size from growing to an enormous+ // amount due to a faulty process.+ DefaultBufSize = 1024++ // DefaultTimeout default limit on time a process can run.+ DefaultTimeout = time.Duration(1) * time.Minute+)++// ProcessProvider satisfies the credentials.Provider interface, and is a+// client to retrieve credentials from a process.+type ProcessProvider struct {+ staticCreds bool+ credentials.Expiry+ originalCommand []string++ // Expiry duration of the credentials. Defaults to 15 minutes if not set.+ Duration time.Duration++ // ExpiryWindow will allow the credentials to trigger refreshing prior to+ // the credentials actually expiring. This is beneficial so race conditions+ // with expiring credentials do not cause request to fail unexpectedly+ // due to ExpiredTokenException exceptions.+ //+ // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true+ // 10 seconds before the credentials are actually expired.+ //+ // If ExpiryWindow is 0 or less it will be ignored.+ ExpiryWindow time.Duration++ // A string representing an os command that should return a JSON with+ // credential information.+ command *exec.Cmd++ // MaxBufSize limits memory usage from growing to an enormous+ // amount due to a faulty process.+ MaxBufSize int++ // Timeout limits the time a process can run.+ Timeout time.Duration+}++// NewCredentials returns a pointer to a new Credentials object wrapping the+// ProcessProvider. The credentials will expire every 15 minutes by default.+func NewCredentials(command string, options ...func(*ProcessProvider)) *credentials.Credentials {+ p := &ProcessProvider{+ command: exec.Command(command),+ Duration: DefaultDuration,+ Timeout: DefaultTimeout,+ MaxBufSize: DefaultBufSize,+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++// NewCredentialsTimeout returns a pointer to a new Credentials object with+// the specified command and timeout, and default duration and max buffer size.+func NewCredentialsTimeout(command string, timeout time.Duration) *credentials.Credentials {+ p := NewCredentials(command, func(opt *ProcessProvider) {+ opt.Timeout = timeout+ })++ return p+}++// NewCredentialsCommand returns a pointer to a new Credentials object with+// the specified command, and default timeout, duration and max buffer size.+func NewCredentialsCommand(command *exec.Cmd, options ...func(*ProcessProvider)) *credentials.Credentials {+ p := &ProcessProvider{+ command: command,+ Duration: DefaultDuration,+ Timeout: DefaultTimeout,+ MaxBufSize: DefaultBufSize,+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++type credentialProcessResponse struct {+ Version int+ AccessKeyID string `json:"AccessKeyId"`+ SecretAccessKey string+ SessionToken string+ Expiration *time.Time+}++// Retrieve executes the 'credential_process' and returns the credentials.+func (p *ProcessProvider) Retrieve() (credentials.Value, error) {+ out, err := p.executeCredentialProcess()+ if err != nil {+ return credentials.Value{ProviderName: ProviderName}, err+ }++ // Serialize and validate response+ resp := &credentialProcessResponse{}+ if err = json.Unmarshal(out, resp); err != nil {+ return credentials.Value{ProviderName: ProviderName}, awserr.New(+ ErrCodeProcessProviderParse,+ fmt.Sprintf("%s: %s", errMsgProcessProviderParse, string(out)),+ err)+ }++ if resp.Version != 1 {+ return credentials.Value{ProviderName: ProviderName}, awserr.New(+ ErrCodeProcessProviderVersion,+ errMsgProcessProviderVersion,+ nil)+ }++ if len(resp.AccessKeyID) == 0 {+ return credentials.Value{ProviderName: ProviderName}, awserr.New(+ ErrCodeProcessProviderRequired,+ errMsgProcessProviderMissKey,+ nil)+ }++ if len(resp.SecretAccessKey) == 0 {+ return credentials.Value{ProviderName: ProviderName}, awserr.New(+ ErrCodeProcessProviderRequired,+ errMsgProcessProviderMissSecret,+ nil)+ }++ // Handle expiration+ p.staticCreds = resp.Expiration == nil+ if resp.Expiration != nil {+ p.SetExpiration(*resp.Expiration, p.ExpiryWindow)+ }++ return credentials.Value{+ ProviderName: ProviderName,+ AccessKeyID: resp.AccessKeyID,+ SecretAccessKey: resp.SecretAccessKey,+ SessionToken: resp.SessionToken,+ }, nil+}++// IsExpired returns true if the credentials retrieved are expired, or not yet+// retrieved.+func (p *ProcessProvider) IsExpired() bool {+ if p.staticCreds {+ return false+ }+ return p.Expiry.IsExpired()+}++// prepareCommand prepares the command to be executed.+func (p *ProcessProvider) prepareCommand() error {++ var cmdArgs []string+ if runtime.GOOS == "windows" {+ cmdArgs = []string{"cmd.exe", "/C"}+ } else {+ cmdArgs = []string{"sh", "-c"}+ }++ if len(p.originalCommand) == 0 {+ p.originalCommand = make([]string, len(p.command.Args))+ copy(p.originalCommand, p.command.Args)++ // check for empty command because it succeeds+ if len(strings.TrimSpace(p.originalCommand[0])) < 1 {+ return awserr.New(+ ErrCodeProcessProviderExecution,+ fmt.Sprintf(+ "%s: %s",+ errMsgProcessProviderPrepareCmd,+ errMsgProcessProviderEmptyCmd),+ nil)+ }+ }++ cmdArgs = append(cmdArgs, p.originalCommand...)+ p.command = exec.Command(cmdArgs[0], cmdArgs[1:]...)+ p.command.Env = os.Environ()++ return nil+}++// executeCredentialProcess starts the credential process on the OS and+// returns the results or an error.+func (p *ProcessProvider) executeCredentialProcess() ([]byte, error) {++ if err := p.prepareCommand(); err != nil {+ return nil, err+ }++ // Setup the pipes+ outReadPipe, outWritePipe, err := os.Pipe()+ if err != nil {+ return nil, awserr.New(+ ErrCodeProcessProviderExecution,+ errMsgProcessProviderPipe,+ err)+ }++ p.command.Stderr = os.Stderr // display stderr on console for MFA+ p.command.Stdout = outWritePipe // get creds json on process's stdout+ p.command.Stdin = os.Stdin // enable stdin for MFA++ output := bytes.NewBuffer(make([]byte, 0, p.MaxBufSize))++ stdoutCh := make(chan error, 1)+ go readInput(+ io.LimitReader(outReadPipe, int64(p.MaxBufSize)),+ output,+ stdoutCh)++ execCh := make(chan error, 1)+ go executeCommand(*p.command, execCh)++ finished := false+ var errors []error+ for !finished {+ select {+ case readError := <-stdoutCh:+ errors = appendError(errors, readError)+ finished = true+ case execError := <-execCh:+ err := outWritePipe.Close()+ errors = appendError(errors, err)+ errors = appendError(errors, execError)+ if errors != nil {+ return output.Bytes(), awserr.NewBatchError(+ ErrCodeProcessProviderExecution,+ errMsgProcessProviderProcess,+ errors)+ }+ case <-time.After(p.Timeout):+ finished = true+ return output.Bytes(), awserr.NewBatchError(+ ErrCodeProcessProviderExecution,+ errMsgProcessProviderTimeout,+ errors) // errors can be nil+ }+ }++ out := output.Bytes()++ if runtime.GOOS == "windows" {+ // windows adds slashes to quotes+ out = []byte(strings.Replace(string(out), `\"`, `"`, -1))+ }++ return out, nil+}++// appendError conveniently checks for nil before appending slice+func appendError(errors []error, err error) []error {+ if err != nil {+ return append(errors, err)+ }+ return errors+}++func executeCommand(cmd exec.Cmd, exec chan error) {+ // Start the command+ err := cmd.Start()+ if err == nil {+ err = cmd.Wait()+ }++ exec <- err+}++func readInput(r io.Reader, w io.Writer, read chan error) {+ tee := io.TeeReader(r, w)++ _, err := ioutil.ReadAll(tee)++ if err == io.EOF {+ err = nil+ }++ read <- err // will only arrive here when write end of pipe is closed+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.gonew file mode 100644index 000000000..e15514958--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider.go@@ -0,0 +1,150 @@+package credentials++import (+ "fmt"+ "os"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/internal/ini"+ "github.com/aws/aws-sdk-go/internal/shareddefaults"+)++// SharedCredsProviderName provides a name of SharedCreds provider+const SharedCredsProviderName = "SharedCredentialsProvider"++var (+ // ErrSharedCredentialsHomeNotFound is emitted when the user directory cannot be found.+ ErrSharedCredentialsHomeNotFound = awserr.New("UserHomeNotFound", "user home directory not found.", nil)+)++// A SharedCredentialsProvider retrieves credentials from the current user's home+// directory, and keeps track if those credentials are expired.+//+// Profile ini file example: $HOME/.aws/credentials+type SharedCredentialsProvider struct {+ // Path to the shared credentials file.+ //+ // If empty will look for "AWS_SHARED_CREDENTIALS_FILE" env variable. If the+ // env value is empty will default to current user's home directory.+ // Linux/OSX: "$HOME/.aws/credentials"+ // Windows: "%USERPROFILE%\.aws\credentials"+ Filename string++ // AWS Profile to extract credentials from the shared credentials file. If empty+ // will default to environment variable "AWS_PROFILE" or "default" if+ // environment variable is also not set.+ Profile string++ // retrieved states if the credentials have been successfully retrieved.+ retrieved bool+}++// NewSharedCredentials returns a pointer to a new Credentials object+// wrapping the Profile file provider.+func NewSharedCredentials(filename, profile string) *Credentials {+ return NewCredentials(&SharedCredentialsProvider{+ Filename: filename,+ Profile: profile,+ })+}++// Retrieve reads and extracts the shared credentials from the current+// users home directory.+func (p *SharedCredentialsProvider) Retrieve() (Value, error) {+ p.retrieved = false++ filename, err := p.filename()+ if err != nil {+ return Value{ProviderName: SharedCredsProviderName}, err+ }++ creds, err := loadProfile(filename, p.profile())+ if err != nil {+ return Value{ProviderName: SharedCredsProviderName}, err+ }++ p.retrieved = true+ return creds, nil+}++// IsExpired returns if the shared credentials have expired.+func (p *SharedCredentialsProvider) IsExpired() bool {+ return !p.retrieved+}++// loadProfiles loads from the file pointed to by shared credentials filename for profile.+// The credentials retrieved from the profile will be returned or error. Error will be+// returned if it fails to read from the file, or the data is invalid.+func loadProfile(filename, profile string) (Value, error) {+ config, err := ini.OpenFile(filename)+ if err != nil {+ return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsLoad", "failed to load shared credentials file", err)+ }++ iniProfile, ok := config.GetSection(profile)+ if !ok {+ return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsLoad", "failed to get profile", nil)+ }++ id := iniProfile.String("aws_access_key_id")+ if len(id) == 0 {+ return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsAccessKey",+ fmt.Sprintf("shared credentials %s in %s did not contain aws_access_key_id", profile, filename),+ nil)+ }++ secret := iniProfile.String("aws_secret_access_key")+ if len(secret) == 0 {+ return Value{ProviderName: SharedCredsProviderName}, awserr.New("SharedCredsSecret",+ fmt.Sprintf("shared credentials %s in %s did not contain aws_secret_access_key", profile, filename),+ nil)+ }++ // Default to empty string if not found+ token := iniProfile.String("aws_session_token")++ return Value{+ AccessKeyID: id,+ SecretAccessKey: secret,+ SessionToken: token,+ ProviderName: SharedCredsProviderName,+ }, nil+}++// filename returns the filename to use to read AWS shared credentials.+//+// Will return an error if the user's home directory path cannot be found.+func (p *SharedCredentialsProvider) filename() (string, error) {+ if len(p.Filename) != 0 {+ return p.Filename, nil+ }++ if p.Filename = os.Getenv("AWS_SHARED_CREDENTIALS_FILE"); len(p.Filename) != 0 {+ return p.Filename, nil+ }++ if home := shareddefaults.UserHomeDir(); len(home) == 0 {+ // Backwards compatibility of home directly not found error being returned.+ // This error is too verbose, failure when opening the file would of been+ // a better error to return.+ return "", ErrSharedCredentialsHomeNotFound+ }++ p.Filename = shareddefaults.SharedCredentialsFilename()++ return p.Filename, nil+}++// profile returns the AWS shared credentials profile. If empty will read+// environment variable "AWS_PROFILE". If that is not set profile will+// return "default".+func (p *SharedCredentialsProvider) profile() string {+ if p.Profile == "" {+ p.Profile = os.Getenv("AWS_PROFILE")+ }+ if p.Profile == "" {+ p.Profile = "default"+ }++ return p.Profile+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.gonew file mode 100644index 000000000..531139e39--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/static_provider.go@@ -0,0 +1,55 @@+package credentials++import (+ "github.com/aws/aws-sdk-go/aws/awserr"+)++// StaticProviderName provides a name of Static provider+const StaticProviderName = "StaticProvider"++var (+ // ErrStaticCredentialsEmpty is emitted when static credentials are empty.+ ErrStaticCredentialsEmpty = awserr.New("EmptyStaticCreds", "static credentials are empty", nil)+)++// A StaticProvider is a set of credentials which are set programmatically,+// and will never expire.+type StaticProvider struct {+ Value+}++// NewStaticCredentials returns a pointer to a new Credentials object+// wrapping a static credentials value provider.+func NewStaticCredentials(id, secret, token string) *Credentials {+ return NewCredentials(&StaticProvider{Value: Value{+ AccessKeyID: id,+ SecretAccessKey: secret,+ SessionToken: token,+ }})+}++// NewStaticCredentialsFromCreds returns a pointer to a new Credentials object+// wrapping the static credentials value provide. Same as NewStaticCredentials+// but takes the creds Value instead of individual fields+func NewStaticCredentialsFromCreds(creds Value) *Credentials {+ return NewCredentials(&StaticProvider{Value: creds})+}++// Retrieve returns the credentials or error if the credentials are invalid.+func (s *StaticProvider) Retrieve() (Value, error) {+ if s.AccessKeyID == "" || s.SecretAccessKey == "" {+ return Value{ProviderName: StaticProviderName}, ErrStaticCredentialsEmpty+ }++ if len(s.Value.ProviderName) == 0 {+ s.Value.ProviderName = StaticProviderName+ }+ return s.Value, nil+}++// IsExpired returns if the credentials are expired.+//+// For StaticProvider, the credentials never expired.+func (s *StaticProvider) IsExpired() bool {+ return false+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go b/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.gonew file mode 100644index 000000000..4108e433e--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go@@ -0,0 +1,298 @@+/*+Package stscreds are credential Providers to retrieve STS AWS credentials.++STS provides multiple ways to retrieve credentials which can be used when making+future AWS service API operation calls.++The SDK will ensure that per instance of credentials.Credentials all requests+to refresh the credentials will be synchronized. But, the SDK is unable to+ensure synchronous usage of the AssumeRoleProvider if the value is shared+between multiple Credentials, Sessions or service clients.++Assume Role++To assume an IAM role using STS with the SDK you can create a new Credentials+with the SDKs's stscreds package.++ // Initial credentials loaded from SDK's default credential chain. Such as+ // the environment, shared credentials (~/.aws/credentials), or EC2 Instance+ // Role. These credentials will be used to to make the STS Assume Role API.+ sess := session.Must(session.NewSession())++ // Create the credentials from AssumeRoleProvider to assume the role+ // referenced by the "myRoleARN" ARN.+ creds := stscreds.NewCredentials(sess, "myRoleArn")++ // Create service client value configured for credentials+ // from assumed role.+ svc := s3.New(sess, &aws.Config{Credentials: creds})++Assume Role with static MFA Token++To assume an IAM role with a MFA token you can either specify a MFA token code+directly or provide a function to prompt the user each time the credentials+need to refresh the role's credentials. Specifying the TokenCode should be used+for short lived operations that will not need to be refreshed, and when you do+not want to have direct control over the user provides their MFA token.++With TokenCode the AssumeRoleProvider will be not be able to refresh the role's+credentials.++ // Create the credentials from AssumeRoleProvider to assume the role+ // referenced by the "myRoleARN" ARN using the MFA token code provided.+ creds := stscreds.NewCredentials(sess, "myRoleArn", func(p *stscreds.AssumeRoleProvider) {+ p.SerialNumber = aws.String("myTokenSerialNumber")+ p.TokenCode = aws.String("00000000")+ })++ // Create service client value configured for credentials+ // from assumed role.+ svc := s3.New(sess, &aws.Config{Credentials: creds})++Assume Role with MFA Token Provider++To assume an IAM role with MFA for longer running tasks where the credentials+may need to be refreshed setting the TokenProvider field of AssumeRoleProvider+will allow the credential provider to prompt for new MFA token code when the+role's credentials need to be refreshed.++The StdinTokenProvider function is available to prompt on stdin to retrieve+the MFA token code from the user. You can also implement custom prompts by+satisfing the TokenProvider function signature.++Using StdinTokenProvider with multiple AssumeRoleProviders, or Credentials will+have undesirable results as the StdinTokenProvider will not be synchronized. A+single Credentials with an AssumeRoleProvider can be shared safely.++ // Create the credentials from AssumeRoleProvider to assume the role+ // referenced by the "myRoleARN" ARN. Prompting for MFA token from stdin.+ creds := stscreds.NewCredentials(sess, "myRoleArn", func(p *stscreds.AssumeRoleProvider) {+ p.SerialNumber = aws.String("myTokenSerialNumber")+ p.TokenProvider = stscreds.StdinTokenProvider+ })++ // Create service client value configured for credentials+ // from assumed role.+ svc := s3.New(sess, &aws.Config{Credentials: creds})++*/+package stscreds++import (+ "fmt"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/service/sts"+)++// StdinTokenProvider will prompt on stdout and read from stdin for a string value.+// An error is returned if reading from stdin fails.+//+// Use this function go read MFA tokens from stdin. The function makes no attempt+// to make atomic prompts from stdin across multiple gorouties.+//+// Using StdinTokenProvider with multiple AssumeRoleProviders, or Credentials will+// have undesirable results as the StdinTokenProvider will not be synchronized. A+// single Credentials with an AssumeRoleProvider can be shared safely+//+// Will wait forever until something is provided on the stdin.+func StdinTokenProvider() (string, error) {+ var v string+ fmt.Printf("Assume Role MFA token code: ")+ _, err := fmt.Scanln(&v)++ return v, err+}++// ProviderName provides a name of AssumeRole provider+const ProviderName = "AssumeRoleProvider"++// AssumeRoler represents the minimal subset of the STS client API used by this provider.+type AssumeRoler interface {+ AssumeRole(input *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error)+}++// DefaultDuration is the default amount of time in minutes that the credentials+// will be valid for.+var DefaultDuration = time.Duration(15) * time.Minute++// AssumeRoleProvider retrieves temporary credentials from the STS service, and+// keeps track of their expiration time.+//+// This credential provider will be used by the SDKs default credential change+// when shared configuration is enabled, and the shared config or shared credentials+// file configure assume role. See Session docs for how to do this.+//+// AssumeRoleProvider does not provide any synchronization and it is not safe+// to share this value across multiple Credentials, Sessions, or service clients+// without also sharing the same Credentials instance.+type AssumeRoleProvider struct {+ credentials.Expiry++ // STS client to make assume role request with.+ Client AssumeRoler++ // Role to be assumed.+ RoleARN string++ // Session name, if you wish to reuse the credentials elsewhere.+ RoleSessionName string++ // Expiry duration of the STS credentials. Defaults to 15 minutes if not set.+ Duration time.Duration++ // Optional ExternalID to pass along, defaults to nil if not set.+ ExternalID *string++ // The policy plain text must be 2048 bytes or shorter. However, an internal+ // conversion compresses it into a packed binary format with a separate limit.+ // The PackedPolicySize response element indicates by percentage how close to+ // the upper size limit the policy is, with 100% equaling the maximum allowed+ // size.+ Policy *string++ // The identification number of the MFA device that is associated with the user+ // who is making the AssumeRole call. Specify this value if the trust policy+ // of the role being assumed includes a condition that requires MFA authentication.+ // The value is either the serial number for a hardware device (such as GAHT12345678)+ // or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).+ SerialNumber *string++ // The value provided by the MFA device, if the trust policy of the role being+ // assumed requires MFA (that is, if the policy includes a condition that tests+ // for MFA). If the role being assumed requires MFA and if the TokenCode value+ // is missing or expired, the AssumeRole call returns an "access denied" error.+ //+ // If SerialNumber is set and neither TokenCode nor TokenProvider are also+ // set an error will be returned.+ TokenCode *string++ // Async method of providing MFA token code for assuming an IAM role with MFA.+ // The value returned by the function will be used as the TokenCode in the Retrieve+ // call. See StdinTokenProvider for a provider that prompts and reads from stdin.+ //+ // This token provider will be called when ever the assumed role's+ // credentials need to be refreshed when SerialNumber is also set and+ // TokenCode is not set.+ //+ // If both TokenCode and TokenProvider is set, TokenProvider will be used and+ // TokenCode is ignored.+ TokenProvider func() (string, error)++ // ExpiryWindow will allow the credentials to trigger refreshing prior to+ // the credentials actually expiring. This is beneficial so race conditions+ // with expiring credentials do not cause request to fail unexpectedly+ // due to ExpiredTokenException exceptions.+ //+ // So a ExpiryWindow of 10s would cause calls to IsExpired() to return true+ // 10 seconds before the credentials are actually expired.+ //+ // If ExpiryWindow is 0 or less it will be ignored.+ ExpiryWindow time.Duration+}++// NewCredentials returns a pointer to a new Credentials object wrapping the+// AssumeRoleProvider. The credentials will expire every 15 minutes and the+// role will be named after a nanosecond timestamp of this operation.+//+// Takes a Config provider to create the STS client. The ConfigProvider is+// satisfied by the session.Session type.+//+// It is safe to share the returned Credentials with multiple Sessions and+// service clients. All access to the credentials and refreshing them+// will be synchronized.+func NewCredentials(c client.ConfigProvider, roleARN string, options ...func(*AssumeRoleProvider)) *credentials.Credentials {+ p := &AssumeRoleProvider{+ Client: sts.New(c),+ RoleARN: roleARN,+ Duration: DefaultDuration,+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++// NewCredentialsWithClient returns a pointer to a new Credentials object wrapping the+// AssumeRoleProvider. The credentials will expire every 15 minutes and the+// role will be named after a nanosecond timestamp of this operation.+//+// Takes an AssumeRoler which can be satisfied by the STS client.+//+// It is safe to share the returned Credentials with multiple Sessions and+// service clients. All access to the credentials and refreshing them+// will be synchronized.+func NewCredentialsWithClient(svc AssumeRoler, roleARN string, options ...func(*AssumeRoleProvider)) *credentials.Credentials {+ p := &AssumeRoleProvider{+ Client: svc,+ RoleARN: roleARN,+ Duration: DefaultDuration,+ }++ for _, option := range options {+ option(p)+ }++ return credentials.NewCredentials(p)+}++// Retrieve generates a new set of temporary credentials using STS.+func (p *AssumeRoleProvider) Retrieve() (credentials.Value, error) {++ // Apply defaults where parameters are not set.+ if p.RoleSessionName == "" {+ // Try to work out a role name that will hopefully end up unique.+ p.RoleSessionName = fmt.Sprintf("%d", time.Now().UTC().UnixNano())+ }+ if p.Duration == 0 {+ // Expire as often as AWS permits.+ p.Duration = DefaultDuration+ }+ input := &sts.AssumeRoleInput{+ DurationSeconds: aws.Int64(int64(p.Duration / time.Second)),+ RoleArn: aws.String(p.RoleARN),+ RoleSessionName: aws.String(p.RoleSessionName),+ ExternalId: p.ExternalID,+ }+ if p.Policy != nil {+ input.Policy = p.Policy+ }+ if p.SerialNumber != nil {+ if p.TokenCode != nil {+ input.SerialNumber = p.SerialNumber+ input.TokenCode = p.TokenCode+ } else if p.TokenProvider != nil {+ input.SerialNumber = p.SerialNumber+ code, err := p.TokenProvider()+ if err != nil {+ return credentials.Value{ProviderName: ProviderName}, err+ }+ input.TokenCode = aws.String(code)+ } else {+ return credentials.Value{ProviderName: ProviderName},+ awserr.New("AssumeRoleTokenNotAvailable",+ "assume role with MFA enabled, but neither TokenCode nor TokenProvider are set", nil)+ }+ }++ roleOutput, err := p.Client.AssumeRole(input)+ if err != nil {+ return credentials.Value{ProviderName: ProviderName}, err+ }++ // We will proactively generate new credentials before they expire.+ p.SetExpiration(*roleOutput.Credentials.Expiration, p.ExpiryWindow)++ return credentials.Value{+ AccessKeyID: *roleOutput.Credentials.AccessKeyId,+ SecretAccessKey: *roleOutput.Credentials.SecretAccessKey,+ SessionToken: *roleOutput.Credentials.SessionToken,+ ProviderName: ProviderName,+ }, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/csm/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/csm/doc.gonew file mode 100644index 000000000..152d785b3--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/csm/doc.go@@ -0,0 +1,46 @@+// Package csm provides Client Side Monitoring (CSM) which enables sending metrics+// via UDP connection. Using the Start function will enable the reporting of+// metrics on a given port. If Start is called, with different parameters, again,+// a panic will occur.+//+// Pause can be called to pause any metrics publishing on a given port. Sessions+// that have had their handlers modified via InjectHandlers may still be used.+// However, the handlers will act as a no-op meaning no metrics will be published.+//+// Example:+// r, err := csm.Start("clientID", ":31000")+// if err != nil {+// panic(fmt.Errorf("failed starting CSM: %v", err))+// }+//+// sess, err := session.NewSession(&aws.Config{})+// if err != nil {+// panic(fmt.Errorf("failed loading session: %v", err))+// }+//+// r.InjectHandlers(&sess.Handlers)+//+// client := s3.New(sess)+// resp, err := client.GetObject(&s3.GetObjectInput{+// Bucket: aws.String("bucket"),+// Key: aws.String("key"),+// })+//+// // Will pause monitoring+// r.Pause()+// resp, err = client.GetObject(&s3.GetObjectInput{+// Bucket: aws.String("bucket"),+// Key: aws.String("key"),+// })+//+// // Resume monitoring+// r.Continue()+//+// Start returns a Reporter that is used to enable or disable monitoring. If+// access to the Reporter is required later, calling Get will return the Reporter+// singleton.+//+// Example:+// r := csm.Get()+// r.Continue()+package csmdiff --git a/vendor/github.com/aws/aws-sdk-go/aws/csm/enable.go b/vendor/github.com/aws/aws-sdk-go/aws/csm/enable.gonew file mode 100644index 000000000..2f0c6eac9--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/csm/enable.go@@ -0,0 +1,67 @@+package csm++import (+ "fmt"+ "sync"+)++var (+ lock sync.Mutex+)++// Client side metric handler names+const (+ APICallMetricHandlerName = "awscsm.SendAPICallMetric"+ APICallAttemptMetricHandlerName = "awscsm.SendAPICallAttemptMetric"+)++// Start will start the a long running go routine to capture+// client side metrics. Calling start multiple time will only+// start the metric listener once and will panic if a different+// client ID or port is passed in.+//+// Example:+// r, err := csm.Start("clientID", "127.0.0.1:8094")+// if err != nil {+// panic(fmt.Errorf("expected no error, but received %v", err))+// }+// sess := session.NewSession()+// r.InjectHandlers(sess.Handlers)+//+// svc := s3.New(sess)+// out, err := svc.GetObject(&s3.GetObjectInput{+// Bucket: aws.String("bucket"),+// Key: aws.String("key"),+// })+func Start(clientID string, url string) (*Reporter, error) {+ lock.Lock()+ defer lock.Unlock()++ if sender == nil {+ sender = newReporter(clientID, url)+ } else {+ if sender.clientID != clientID {+ panic(fmt.Errorf("inconsistent client IDs. %q was expected, but received %q", sender.clientID, clientID))+ }++ if sender.url != url {+ panic(fmt.Errorf("inconsistent URLs. %q was expected, but received %q", sender.url, url))+ }+ }++ if err := connect(url); err != nil {+ sender = nil+ return nil, err+ }++ return sender, nil+}++// Get will return a reporter if one exists, if one does not exist, nil will+// be returned.+func Get() *Reporter {+ lock.Lock()+ defer lock.Unlock()++ return sender+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/csm/metric.go b/vendor/github.com/aws/aws-sdk-go/aws/csm/metric.gonew file mode 100644index 000000000..6f57024d7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/csm/metric.go@@ -0,0 +1,53 @@+package csm++import (+ "strconv"+ "time"+)++type metricTime time.Time++func (t metricTime) MarshalJSON() ([]byte, error) {+ ns := time.Duration(time.Time(t).UnixNano())+ return []byte(strconv.FormatInt(int64(ns/time.Millisecond), 10)), nil+}++type metric struct {+ ClientID *string `json:"ClientId,omitempty"`+ API *string `json:"Api,omitempty"`+ Service *string `json:"Service,omitempty"`+ Timestamp *metricTime `json:"Timestamp,omitempty"`+ Type *string `json:"Type,omitempty"`+ Version *int `json:"Version,omitempty"`++ AttemptCount *int `json:"AttemptCount,omitempty"`+ Latency *int `json:"Latency,omitempty"`++ Fqdn *string `json:"Fqdn,omitempty"`+ UserAgent *string `json:"UserAgent,omitempty"`+ AttemptLatency *int `json:"AttemptLatency,omitempty"`++ SessionToken *string `json:"SessionToken,omitempty"`+ Region *string `json:"Region,omitempty"`+ AccessKey *string `json:"AccessKey,omitempty"`+ HTTPStatusCode *int `json:"HttpStatusCode,omitempty"`+ XAmzID2 *string `json:"XAmzId2,omitempty"`+ XAmzRequestID *string `json:"XAmznRequestId,omitempty"`++ AWSException *string `json:"AwsException,omitempty"`+ AWSExceptionMessage *string `json:"AwsExceptionMessage,omitempty"`+ SDKException *string `json:"SdkException,omitempty"`+ SDKExceptionMessage *string `json:"SdkExceptionMessage,omitempty"`++ DestinationIP *string `json:"DestinationIp,omitempty"`+ ConnectionReused *int `json:"ConnectionReused,omitempty"`++ AcquireConnectionLatency *int `json:"AcquireConnectionLatency,omitempty"`+ ConnectLatency *int `json:"ConnectLatency,omitempty"`+ RequestLatency *int `json:"RequestLatency,omitempty"`+ DNSLatency *int `json:"DnsLatency,omitempty"`+ TCPLatency *int `json:"TcpLatency,omitempty"`+ SSLLatency *int `json:"SslLatency,omitempty"`++ MaxRetriesExceeded *int `json:"MaxRetriesExceeded,omitempty"`+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/csm/metric_chan.go b/vendor/github.com/aws/aws-sdk-go/aws/csm/metric_chan.gonew file mode 100644index 000000000..514fc3739--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/csm/metric_chan.go@@ -0,0 +1,54 @@+package csm++import (+ "sync/atomic"+)++const (+ runningEnum = iota+ pausedEnum+)++var (+ // MetricsChannelSize of metrics to hold in the channel+ MetricsChannelSize = 100+)++type metricChan struct {+ ch chan metric+ paused int64+}++func newMetricChan(size int) metricChan {+ return metricChan{+ ch: make(chan metric, size),+ }+}++func (ch *metricChan) Pause() {+ atomic.StoreInt64(&ch.paused, pausedEnum)+}++func (ch *metricChan) Continue() {+ atomic.StoreInt64(&ch.paused, runningEnum)+}++func (ch *metricChan) IsPaused() bool {+ v := atomic.LoadInt64(&ch.paused)+ return v == pausedEnum+}++// Push will push metrics to the metric channel if the channel+// is not paused+func (ch *metricChan) Push(m metric) bool {+ if ch.IsPaused() {+ return false+ }++ select {+ case ch.ch <- m:+ return true+ default:+ return false+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/csm/reporter.go b/vendor/github.com/aws/aws-sdk-go/aws/csm/reporter.gonew file mode 100644index 000000000..9a5697c25--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/csm/reporter.go@@ -0,0 +1,240 @@+package csm++import (+ "encoding/json"+ "net"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++const (+ // DefaultPort is used when no port is specified+ DefaultPort = "31000"+)++// Reporter will gather metrics of API requests made and+// send those metrics to the CSM endpoint.+type Reporter struct {+ clientID string+ url string+ conn net.Conn+ metricsCh metricChan+ done chan struct{}+}++var (+ sender *Reporter+)++func connect(url string) error {+ const network = "udp"+ if err := sender.connect(network, url); err != nil {+ return err+ }++ if sender.done == nil {+ sender.done = make(chan struct{})+ go sender.start()+ }++ return nil+}++func newReporter(clientID, url string) *Reporter {+ return &Reporter{+ clientID: clientID,+ url: url,+ metricsCh: newMetricChan(MetricsChannelSize),+ }+}++func (rep *Reporter) sendAPICallAttemptMetric(r *request.Request) {+ if rep == nil {+ return+ }++ now := time.Now()+ creds, _ := r.Config.Credentials.Get()++ m := metric{+ ClientID: aws.String(rep.clientID),+ API: aws.String(r.Operation.Name),+ Service: aws.String(r.ClientInfo.ServiceID),+ Timestamp: (*metricTime)(&now),+ UserAgent: aws.String(r.HTTPRequest.Header.Get("User-Agent")),+ Region: r.Config.Region,+ Type: aws.String("ApiCallAttempt"),+ Version: aws.Int(1),++ XAmzRequestID: aws.String(r.RequestID),++ AttemptCount: aws.Int(r.RetryCount + 1),+ AttemptLatency: aws.Int(int(now.Sub(r.AttemptTime).Nanoseconds() / int64(time.Millisecond))),+ AccessKey: aws.String(creds.AccessKeyID),+ }++ if r.HTTPResponse != nil {+ m.HTTPStatusCode = aws.Int(r.HTTPResponse.StatusCode)+ }++ if r.Error != nil {+ if awserr, ok := r.Error.(awserr.Error); ok {+ setError(&m, awserr)+ }+ }++ rep.metricsCh.Push(m)+}++func setError(m *metric, err awserr.Error) {+ msg := err.Error()+ code := err.Code()++ switch code {+ case "RequestError",+ "SerializationError",+ request.CanceledErrorCode:+ m.SDKException = &code+ m.SDKExceptionMessage = &msg+ default:+ m.AWSException = &code+ m.AWSExceptionMessage = &msg+ }+}++func (rep *Reporter) sendAPICallMetric(r *request.Request) {+ if rep == nil {+ return+ }++ now := time.Now()+ m := metric{+ ClientID: aws.String(rep.clientID),+ API: aws.String(r.Operation.Name),+ Service: aws.String(r.ClientInfo.ServiceID),+ Timestamp: (*metricTime)(&now),+ Type: aws.String("ApiCall"),+ AttemptCount: aws.Int(r.RetryCount + 1),+ Region: r.Config.Region,+ Latency: aws.Int(int(time.Now().Sub(r.Time) / time.Millisecond)),+ XAmzRequestID: aws.String(r.RequestID),+ MaxRetriesExceeded: aws.Int(boolIntValue(r.RetryCount >= r.MaxRetries())),+ }++ // TODO: Probably want to figure something out for logging dropped+ // metrics+ rep.metricsCh.Push(m)+}++func (rep *Reporter) connect(network, url string) error {+ if rep.conn != nil {+ rep.conn.Close()+ }++ conn, err := net.Dial(network, url)+ if err != nil {+ return awserr.New("UDPError", "Could not connect", err)+ }++ rep.conn = conn++ return nil+}++func (rep *Reporter) close() {+ if rep.done != nil {+ close(rep.done)+ }++ rep.metricsCh.Pause()+}++func (rep *Reporter) start() {+ defer func() {+ rep.metricsCh.Pause()+ }()++ for {+ select {+ case <-rep.done:+ rep.done = nil+ return+ case m := <-rep.metricsCh.ch:+ // TODO: What to do with this error? Probably should just log+ b, err := json.Marshal(m)+ if err != nil {+ continue+ }++ rep.conn.Write(b)+ }+ }+}++// Pause will pause the metric channel preventing any new metrics from+// being added.+func (rep *Reporter) Pause() {+ lock.Lock()+ defer lock.Unlock()++ if rep == nil {+ return+ }++ rep.close()+}++// Continue will reopen the metric channel and allow for monitoring+// to be resumed.+func (rep *Reporter) Continue() {+ lock.Lock()+ defer lock.Unlock()+ if rep == nil {+ return+ }++ if !rep.metricsCh.IsPaused() {+ return+ }++ rep.metricsCh.Continue()+}++// InjectHandlers will will enable client side metrics and inject the proper+// handlers to handle how metrics are sent.+//+// Example:+// // Start must be called in order to inject the correct handlers+// r, err := csm.Start("clientID", "127.0.0.1:8094")+// if err != nil {+// panic(fmt.Errorf("expected no error, but received %v", err))+// }+//+// sess := session.NewSession()+// r.InjectHandlers(&sess.Handlers)+//+// // create a new service client with our client side metric session+// svc := s3.New(sess)+func (rep *Reporter) InjectHandlers(handlers *request.Handlers) {+ if rep == nil {+ return+ }++ apiCallHandler := request.NamedHandler{Name: APICallMetricHandlerName, Fn: rep.sendAPICallMetric}+ apiCallAttemptHandler := request.NamedHandler{Name: APICallAttemptMetricHandlerName, Fn: rep.sendAPICallAttemptMetric}++ handlers.Complete.PushFrontNamed(apiCallHandler)+ handlers.CompleteAttempt.PushFrontNamed(apiCallAttemptHandler)+}++// boolIntValue return 1 for true and 0 for false.+func boolIntValue(b bool) int {+ if b {+ return 1+ }++ return 0+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go b/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.gonew file mode 100644index 000000000..23bb639e0--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/defaults/defaults.go@@ -0,0 +1,207 @@+// Package defaults is a collection of helpers to retrieve the SDK's default+// configuration and handlers.+//+// Generally this package shouldn't be used directly, but session.Session+// instead. This package is useful when you need to reset the defaults+// of a session or service client to the SDK defaults before setting+// additional parameters.+package defaults++import (+ "fmt"+ "net"+ "net/http"+ "net/url"+ "os"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/corehandlers"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"+ "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds"+ "github.com/aws/aws-sdk-go/aws/ec2metadata"+ "github.com/aws/aws-sdk-go/aws/endpoints"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/shareddefaults"+)++// A Defaults provides a collection of default values for SDK clients.+type Defaults struct {+ Config *aws.Config+ Handlers request.Handlers+}++// Get returns the SDK's default values with Config and handlers pre-configured.+func Get() Defaults {+ cfg := Config()+ handlers := Handlers()+ cfg.Credentials = CredChain(cfg, handlers)++ return Defaults{+ Config: cfg,+ Handlers: handlers,+ }+}++// Config returns the default configuration without credentials.+// To retrieve a config with credentials also included use+// `defaults.Get().Config` instead.+//+// Generally you shouldn't need to use this method directly, but+// is available if you need to reset the configuration of an+// existing service client or session.+func Config() *aws.Config {+ return aws.NewConfig().+ WithCredentials(credentials.AnonymousCredentials).+ WithRegion(os.Getenv("AWS_REGION")).+ WithHTTPClient(http.DefaultClient).+ WithMaxRetries(aws.UseServiceDefaultRetries).+ WithLogger(aws.NewDefaultLogger()).+ WithLogLevel(aws.LogOff).+ WithEndpointResolver(endpoints.DefaultResolver())+}++// Handlers returns the default request handlers.+//+// Generally you shouldn't need to use this method directly, but+// is available if you need to reset the request handlers of an+// existing service client or session.+func Handlers() request.Handlers {+ var handlers request.Handlers++ handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)+ handlers.Validate.AfterEachFn = request.HandlerListStopOnError+ handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)+ handlers.Build.PushBackNamed(corehandlers.AddHostExecEnvUserAgentHander)+ handlers.Build.AfterEachFn = request.HandlerListStopOnError+ handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)+ handlers.Send.PushBackNamed(corehandlers.ValidateReqSigHandler)+ handlers.Send.PushBackNamed(corehandlers.SendHandler)+ handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)+ handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)++ return handlers+}++// CredChain returns the default credential chain.+//+// Generally you shouldn't need to use this method directly, but+// is available if you need to reset the credentials of an+// existing service client or session's Config.+func CredChain(cfg *aws.Config, handlers request.Handlers) *credentials.Credentials {+ return credentials.NewCredentials(&credentials.ChainProvider{+ VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors),+ Providers: CredProviders(cfg, handlers),+ })+}++// CredProviders returns the slice of providers used in+// the default credential chain.+//+// For applications that need to use some other provider (for example use+// different environment variables for legacy reasons) but still fall back+// on the default chain of providers. This allows that default chaint to be+// automatically updated+func CredProviders(cfg *aws.Config, handlers request.Handlers) []credentials.Provider {+ return []credentials.Provider{+ &credentials.EnvProvider{},+ &credentials.SharedCredentialsProvider{Filename: "", Profile: ""},+ RemoteCredProvider(*cfg, handlers),+ }+}++const (+ httpProviderAuthorizationEnvVar = "AWS_CONTAINER_AUTHORIZATION_TOKEN"+ httpProviderEnvVar = "AWS_CONTAINER_CREDENTIALS_FULL_URI"+)++// RemoteCredProvider returns a credentials provider for the default remote+// endpoints such as EC2 or ECS Roles.+func RemoteCredProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider {+ if u := os.Getenv(httpProviderEnvVar); len(u) > 0 {+ return localHTTPCredProvider(cfg, handlers, u)+ }++ if uri := os.Getenv(shareddefaults.ECSCredsProviderEnvVar); len(uri) > 0 {+ u := fmt.Sprintf("%s%s", shareddefaults.ECSContainerCredentialsURI, uri)+ return httpCredProvider(cfg, handlers, u)+ }++ return ec2RoleProvider(cfg, handlers)+}++var lookupHostFn = net.LookupHost++func isLoopbackHost(host string) (bool, error) {+ ip := net.ParseIP(host)+ if ip != nil {+ return ip.IsLoopback(), nil+ }++ // Host is not an ip, perform lookup+ addrs, err := lookupHostFn(host)+ if err != nil {+ return false, err+ }+ for _, addr := range addrs {+ if !net.ParseIP(addr).IsLoopback() {+ return false, nil+ }+ }++ return true, nil+}++func localHTTPCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider {+ var errMsg string++ parsed, err := url.Parse(u)+ if err != nil {+ errMsg = fmt.Sprintf("invalid URL, %v", err)+ } else {+ host := aws.URLHostname(parsed)+ if len(host) == 0 {+ errMsg = "unable to parse host from local HTTP cred provider URL"+ } else if isLoopback, loopbackErr := isLoopbackHost(host); loopbackErr != nil {+ errMsg = fmt.Sprintf("failed to resolve host %q, %v", host, loopbackErr)+ } else if !isLoopback {+ errMsg = fmt.Sprintf("invalid endpoint host, %q, only loopback hosts are allowed.", host)+ }+ }++ if len(errMsg) > 0 {+ if cfg.Logger != nil {+ cfg.Logger.Log("Ignoring, HTTP credential provider", errMsg, err)+ }+ return credentials.ErrorProvider{+ Err: awserr.New("CredentialsEndpointError", errMsg, err),+ ProviderName: endpointcreds.ProviderName,+ }+ }++ return httpCredProvider(cfg, handlers, u)+}++func httpCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider {+ return endpointcreds.NewProviderClient(cfg, handlers, u,+ func(p *endpointcreds.Provider) {+ p.ExpiryWindow = 5 * time.Minute+ p.AuthorizationToken = os.Getenv(httpProviderAuthorizationEnvVar)+ },+ )+}++func ec2RoleProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider {+ resolver := cfg.EndpointResolver+ if resolver == nil {+ resolver = endpoints.DefaultResolver()+ }++ e, _ := resolver.EndpointFor(endpoints.Ec2metadataServiceID, "")+ return &ec2rolecreds.EC2RoleProvider{+ Client: ec2metadata.NewClient(cfg, handlers, e.URL, e.SigningRegion),+ ExpiryWindow: 5 * time.Minute,+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/defaults/shared_config.go b/vendor/github.com/aws/aws-sdk-go/aws/defaults/shared_config.gonew file mode 100644index 000000000..ca0ee1dcc--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/defaults/shared_config.go@@ -0,0 +1,27 @@+package defaults++import (+ "github.com/aws/aws-sdk-go/internal/shareddefaults"+)++// SharedCredentialsFilename returns the SDK's default file path+// for the shared credentials file.+//+// Builds the shared config file path based on the OS's platform.+//+// - Linux/Unix: $HOME/.aws/credentials+// - Windows: %USERPROFILE%\.aws\credentials+func SharedCredentialsFilename() string {+ return shareddefaults.SharedCredentialsFilename()+}++// SharedConfigFilename returns the SDK's default file path for+// the shared config file.+//+// Builds the shared config file path based on the OS's platform.+//+// - Linux/Unix: $HOME/.aws/config+// - Windows: %USERPROFILE%\.aws\config+func SharedConfigFilename() string {+ return shareddefaults.SharedConfigFilename()+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/doc.gonew file mode 100644index 000000000..4fcb61618--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/doc.go@@ -0,0 +1,56 @@+// Package aws provides the core SDK's utilities and shared types. Use this package's+// utilities to simplify setting and reading API operations parameters.+//+// Value and Pointer Conversion Utilities+//+// This package includes a helper conversion utility for each scalar type the SDK's+// API use. These utilities make getting a pointer of the scalar, and dereferencing+// a pointer easier.+//+// Each conversion utility comes in two forms. Value to Pointer and Pointer to Value.+// The Pointer to value will safely dereference the pointer and return its value.+// If the pointer was nil, the scalar's zero value will be returned.+//+// The value to pointer functions will be named after the scalar type. So get a+// *string from a string value use the "String" function. This makes it easy to+// to get pointer of a literal string value, because getting the address of a+// literal requires assigning the value to a variable first.+//+// var strPtr *string+//+// // Without the SDK's conversion functions+// str := "my string"+// strPtr = &str+//+// // With the SDK's conversion functions+// strPtr = aws.String("my string")+//+// // Convert *string to string value+// str = aws.StringValue(strPtr)+//+// In addition to scalars the aws package also includes conversion utilities for+// map and slice for commonly types used in API parameters. The map and slice+// conversion functions use similar naming pattern as the scalar conversion+// functions.+//+// var strPtrs []*string+// var strs []string = []string{"Go", "Gophers", "Go"}+//+// // Convert []string to []*string+// strPtrs = aws.StringSlice(strs)+//+// // Convert []*string to []string+// strs = aws.StringValueSlice(strPtrs)+//+// SDK Default HTTP Client+//+// The SDK will use the http.DefaultClient if a HTTP client is not provided to+// the SDK's Session, or service client constructor. This means that if the+// http.DefaultClient is modified by other components of your application the+// modifications will be picked up by the SDK as well.+//+// In some cases this might be intended, but it is a better practice to create+// a custom HTTP Client to share explicitly through your application. You can+// configure the SDK to use the custom HTTP Client by setting the HTTPClient+// value of the SDK's Config type when creating a Session or service client.+package awsdiff --git a/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.gonew file mode 100644index 000000000..c215cd3f5--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go@@ -0,0 +1,162 @@+package ec2metadata++import (+ "encoding/json"+ "fmt"+ "net/http"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/sdkuri"+)++// GetMetadata uses the path provided to request information from the EC2+// instance metdata service. The content will be returned as a string, or+// error if the request failed.+func (c *EC2Metadata) GetMetadata(p string) (string, error) {+ op := &request.Operation{+ Name: "GetMetadata",+ HTTPMethod: "GET",+ HTTPPath: sdkuri.PathJoin("/meta-data", p),+ }++ output := &metadataOutput{}+ req := c.NewRequest(op, nil, output)++ return output.Content, req.Send()+}++// GetUserData returns the userdata that was configured for the service. If+// there is no user-data setup for the EC2 instance a "NotFoundError" error+// code will be returned.+func (c *EC2Metadata) GetUserData() (string, error) {+ op := &request.Operation{+ Name: "GetUserData",+ HTTPMethod: "GET",+ HTTPPath: "/user-data",+ }++ output := &metadataOutput{}+ req := c.NewRequest(op, nil, output)+ req.Handlers.UnmarshalError.PushBack(func(r *request.Request) {+ if r.HTTPResponse.StatusCode == http.StatusNotFound {+ r.Error = awserr.New("NotFoundError", "user-data not found", r.Error)+ }+ })++ return output.Content, req.Send()+}++// GetDynamicData uses the path provided to request information from the EC2+// instance metadata service for dynamic data. The content will be returned+// as a string, or error if the request failed.+func (c *EC2Metadata) GetDynamicData(p string) (string, error) {+ op := &request.Operation{+ Name: "GetDynamicData",+ HTTPMethod: "GET",+ HTTPPath: sdkuri.PathJoin("/dynamic", p),+ }++ output := &metadataOutput{}+ req := c.NewRequest(op, nil, output)++ return output.Content, req.Send()+}++// GetInstanceIdentityDocument retrieves an identity document describing an+// instance. Error is returned if the request fails or is unable to parse+// the response.+func (c *EC2Metadata) GetInstanceIdentityDocument() (EC2InstanceIdentityDocument, error) {+ resp, err := c.GetDynamicData("instance-identity/document")+ if err != nil {+ return EC2InstanceIdentityDocument{},+ awserr.New("EC2MetadataRequestError",+ "failed to get EC2 instance identity document", err)+ }++ doc := EC2InstanceIdentityDocument{}+ if err := json.NewDecoder(strings.NewReader(resp)).Decode(&doc); err != nil {+ return EC2InstanceIdentityDocument{},+ awserr.New("SerializationError",+ "failed to decode EC2 instance identity document", err)+ }++ return doc, nil+}++// IAMInfo retrieves IAM info from the metadata API+func (c *EC2Metadata) IAMInfo() (EC2IAMInfo, error) {+ resp, err := c.GetMetadata("iam/info")+ if err != nil {+ return EC2IAMInfo{},+ awserr.New("EC2MetadataRequestError",+ "failed to get EC2 IAM info", err)+ }++ info := EC2IAMInfo{}+ if err := json.NewDecoder(strings.NewReader(resp)).Decode(&info); err != nil {+ return EC2IAMInfo{},+ awserr.New("SerializationError",+ "failed to decode EC2 IAM info", err)+ }++ if info.Code != "Success" {+ errMsg := fmt.Sprintf("failed to get EC2 IAM Info (%s)", info.Code)+ return EC2IAMInfo{},+ awserr.New("EC2MetadataError", errMsg, nil)+ }++ return info, nil+}++// Region returns the region the instance is running in.+func (c *EC2Metadata) Region() (string, error) {+ resp, err := c.GetMetadata("placement/availability-zone")+ if err != nil {+ return "", err+ }++ // returns region without the suffix. Eg: us-west-2a becomes us-west-2+ return resp[:len(resp)-1], nil+}++// Available returns if the application has access to the EC2 Metadata service.+// Can be used to determine if application is running within an EC2 Instance and+// the metadata service is available.+func (c *EC2Metadata) Available() bool {+ if _, err := c.GetMetadata("instance-id"); err != nil {+ return false+ }++ return true+}++// An EC2IAMInfo provides the shape for unmarshaling+// an IAM info from the metadata API+type EC2IAMInfo struct {+ Code string+ LastUpdated time.Time+ InstanceProfileArn string+ InstanceProfileID string+}++// An EC2InstanceIdentityDocument provides the shape for unmarshaling+// an instance identity document+type EC2InstanceIdentityDocument struct {+ DevpayProductCodes []string `json:"devpayProductCodes"`+ AvailabilityZone string `json:"availabilityZone"`+ PrivateIP string `json:"privateIp"`+ Version string `json:"version"`+ Region string `json:"region"`+ InstanceID string `json:"instanceId"`+ BillingProducts []string `json:"billingProducts"`+ InstanceType string `json:"instanceType"`+ AccountID string `json:"accountId"`+ PendingTime time.Time `json:"pendingTime"`+ ImageID string `json:"imageId"`+ KernelID string `json:"kernelId"`+ RamdiskID string `json:"ramdiskId"`+ Architecture string `json:"architecture"`+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.gonew file mode 100644index 000000000..53457cac3--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go@@ -0,0 +1,149 @@+// Package ec2metadata provides the client for making API calls to the+// EC2 Metadata service.+//+// This package's client can be disabled completely by setting the environment+// variable "AWS_EC2_METADATA_DISABLED=true". This environment variable set to+// true instructs the SDK to disable the EC2 Metadata client. The client cannot+// be used while the environemnt variable is set to true, (case insensitive).+package ec2metadata++import (+ "bytes"+ "errors"+ "io"+ "net/http"+ "os"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/corehandlers"+ "github.com/aws/aws-sdk-go/aws/request"+)++// ServiceName is the name of the service.+const ServiceName = "ec2metadata"+const disableServiceEnvVar = "AWS_EC2_METADATA_DISABLED"++// A EC2Metadata is an EC2 Metadata service Client.+type EC2Metadata struct {+ *client.Client+}++// New creates a new instance of the EC2Metadata client with a session.+// This client is safe to use across multiple goroutines.+//+//+// Example:+// // Create a EC2Metadata client from just a session.+// svc := ec2metadata.New(mySession)+//+// // Create a EC2Metadata client with additional configuration+// svc := ec2metadata.New(mySession, aws.NewConfig().WithLogLevel(aws.LogDebugHTTPBody))+func New(p client.ConfigProvider, cfgs ...*aws.Config) *EC2Metadata {+ c := p.ClientConfig(ServiceName, cfgs...)+ return NewClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)+}++// NewClient returns a new EC2Metadata client. Should be used to create+// a client when not using a session. Generally using just New with a session+// is preferred.+//+// If an unmodified HTTP client is provided from the stdlib default, or no client+// the EC2RoleProvider's EC2Metadata HTTP client's timeout will be shortened.+// To disable this set Config.EC2MetadataDisableTimeoutOverride to false. Enabled by default.+func NewClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string, opts ...func(*client.Client)) *EC2Metadata {+ if !aws.BoolValue(cfg.EC2MetadataDisableTimeoutOverride) && httpClientZero(cfg.HTTPClient) {+ // If the http client is unmodified and this feature is not disabled+ // set custom timeouts for EC2Metadata requests.+ cfg.HTTPClient = &http.Client{+ // use a shorter timeout than default because the metadata+ // service is local if it is running, and to fail faster+ // if not running on an ec2 instance.+ Timeout: 5 * time.Second,+ }+ }++ svc := &EC2Metadata{+ Client: client.New(+ cfg,+ metadata.ClientInfo{+ ServiceName: ServiceName,+ ServiceID: ServiceName,+ Endpoint: endpoint,+ APIVersion: "latest",+ },+ handlers,+ ),+ }++ svc.Handlers.Unmarshal.PushBack(unmarshalHandler)+ svc.Handlers.UnmarshalError.PushBack(unmarshalError)+ svc.Handlers.Validate.Clear()+ svc.Handlers.Validate.PushBack(validateEndpointHandler)++ // Disable the EC2 Metadata service if the environment variable is set.+ // This shortcirctes the service's functionality to always fail to send+ // requests.+ if strings.ToLower(os.Getenv(disableServiceEnvVar)) == "true" {+ svc.Handlers.Send.SwapNamed(request.NamedHandler{+ Name: corehandlers.SendHandler.Name,+ Fn: func(r *request.Request) {+ r.Error = awserr.New(+ request.CanceledErrorCode,+ "EC2 IMDS access disabled via "+disableServiceEnvVar+" env var",+ nil)+ },+ })+ }++ // Add additional options to the service config+ for _, option := range opts {+ option(svc.Client)+ }++ return svc+}++func httpClientZero(c *http.Client) bool {+ return c == nil || (c.Transport == nil && c.CheckRedirect == nil && c.Jar == nil && c.Timeout == 0)+}++type metadataOutput struct {+ Content string+}++func unmarshalHandler(r *request.Request) {+ defer r.HTTPResponse.Body.Close()+ b := &bytes.Buffer{}+ if _, err := io.Copy(b, r.HTTPResponse.Body); err != nil {+ r.Error = awserr.New("SerializationError", "unable to unmarshal EC2 metadata respose", err)+ return+ }++ if data, ok := r.Data.(*metadataOutput); ok {+ data.Content = b.String()+ }+}++func unmarshalError(r *request.Request) {+ defer r.HTTPResponse.Body.Close()+ b := &bytes.Buffer{}+ if _, err := io.Copy(b, r.HTTPResponse.Body); err != nil {+ r.Error = awserr.New("SerializationError", "unable to unmarshal EC2 metadata error respose", err)+ return+ }++ // Response body format is not consistent between metadata endpoints.+ // Grab the error message as a string and include that as the source error+ r.Error = awserr.New("EC2MetadataError", "failed to make EC2Metadata request", errors.New(b.String()))+}++func validateEndpointHandler(r *request.Request) {+ if r.ClientInfo.Endpoint == "" {+ r.Error = aws.ErrMissingEndpoint+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.gonew file mode 100644index 000000000..1ddeae101--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/decode.go@@ -0,0 +1,160 @@+package endpoints++import (+ "encoding/json"+ "fmt"+ "io"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++type modelDefinition map[string]json.RawMessage++// A DecodeModelOptions are the options for how the endpoints model definition+// are decoded.+type DecodeModelOptions struct {+ SkipCustomizations bool+}++// Set combines all of the option functions together.+func (d *DecodeModelOptions) Set(optFns ...func(*DecodeModelOptions)) {+ for _, fn := range optFns {+ fn(d)+ }+}++// DecodeModel unmarshals a Regions and Endpoint model definition file into+// a endpoint Resolver. If the file format is not supported, or an error occurs+// when unmarshaling the model an error will be returned.+//+// Casting the return value of this func to a EnumPartitions will+// allow you to get a list of the partitions in the order the endpoints+// will be resolved in.+//+// resolver, err := endpoints.DecodeModel(reader)+//+// partitions := resolver.(endpoints.EnumPartitions).Partitions()+// for _, p := range partitions {+// // ... inspect partitions+// }+func DecodeModel(r io.Reader, optFns ...func(*DecodeModelOptions)) (Resolver, error) {+ var opts DecodeModelOptions+ opts.Set(optFns...)++ // Get the version of the partition file to determine what+ // unmarshaling model to use.+ modelDef := modelDefinition{}+ if err := json.NewDecoder(r).Decode(&modelDef); err != nil {+ return nil, newDecodeModelError("failed to decode endpoints model", err)+ }++ var version string+ if b, ok := modelDef["version"]; ok {+ version = string(b)+ } else {+ return nil, newDecodeModelError("endpoints version not found in model", nil)+ }++ if version == "3" {+ return decodeV3Endpoints(modelDef, opts)+ }++ return nil, newDecodeModelError(+ fmt.Sprintf("endpoints version %s, not supported", version), nil)+}++func decodeV3Endpoints(modelDef modelDefinition, opts DecodeModelOptions) (Resolver, error) {+ b, ok := modelDef["partitions"]+ if !ok {+ return nil, newDecodeModelError("endpoints model missing partitions", nil)+ }++ ps := partitions{}+ if err := json.Unmarshal(b, &ps); err != nil {+ return nil, newDecodeModelError("failed to decode endpoints model", err)+ }++ if opts.SkipCustomizations {+ return ps, nil+ }++ // Customization+ for i := 0; i < len(ps); i++ {+ p := &ps[i]+ custAddEC2Metadata(p)+ custAddS3DualStack(p)+ custRmIotDataService(p)+ custFixAppAutoscalingChina(p)+ }++ return ps, nil+}++func custAddS3DualStack(p *partition) {+ if p.ID != "aws" {+ return+ }++ custAddDualstack(p, "s3")+ custAddDualstack(p, "s3-control")+}++func custAddDualstack(p *partition, svcName string) {+ s, ok := p.Services[svcName]+ if !ok {+ return+ }++ s.Defaults.HasDualStack = boxedTrue+ s.Defaults.DualStackHostname = "{service}.dualstack.{region}.{dnsSuffix}"++ p.Services[svcName] = s+}++func custAddEC2Metadata(p *partition) {+ p.Services["ec2metadata"] = service{+ IsRegionalized: boxedFalse,+ PartitionEndpoint: "aws-global",+ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "169.254.169.254/latest",+ Protocols: []string{"http"},+ },+ },+ }+}++func custRmIotDataService(p *partition) {+ delete(p.Services, "data.iot")+}++func custFixAppAutoscalingChina(p *partition) {+ if p.ID != "aws-cn" {+ return+ }++ const serviceName = "application-autoscaling"+ s, ok := p.Services[serviceName]+ if !ok {+ return+ }++ const expectHostname = `autoscaling.{region}.amazonaws.com`+ if e, a := s.Defaults.Hostname, expectHostname; e != a {+ fmt.Printf("custFixAppAutoscalingChina: ignoring customization, expected %s, got %s\n", e, a)+ return+ }++ s.Defaults.Hostname = expectHostname + ".cn"+ p.Services[serviceName] = s+}++type decodeModelError struct {+ awsError+}++func newDecodeModelError(msg string, err error) decodeModelError {+ return decodeModelError{+ awsError: awserr.New("DecodeEndpointsModelError", msg, err),+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.gonew file mode 100644index 000000000..c3bbaa0cd--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go@@ -0,0 +1,3690 @@+// Code generated by aws/endpoints/v3model_codegen.go. DO NOT EDIT.++package endpoints++import (+ "regexp"+)++// Partition identifiers+const (+ AwsPartitionID = "aws" // AWS Standard partition.+ AwsCnPartitionID = "aws-cn" // AWS China partition.+ AwsUsGovPartitionID = "aws-us-gov" // AWS GovCloud (US) partition.+)++// AWS Standard partition's regions.+const (+ ApNortheast1RegionID = "ap-northeast-1" // Asia Pacific (Tokyo).+ ApNortheast2RegionID = "ap-northeast-2" // Asia Pacific (Seoul).+ ApSouth1RegionID = "ap-south-1" // Asia Pacific (Mumbai).+ ApSoutheast1RegionID = "ap-southeast-1" // Asia Pacific (Singapore).+ ApSoutheast2RegionID = "ap-southeast-2" // Asia Pacific (Sydney).+ CaCentral1RegionID = "ca-central-1" // Canada (Central).+ EuCentral1RegionID = "eu-central-1" // EU (Frankfurt).+ EuNorth1RegionID = "eu-north-1" // EU (Stockholm).+ EuWest1RegionID = "eu-west-1" // EU (Ireland).+ EuWest2RegionID = "eu-west-2" // EU (London).+ EuWest3RegionID = "eu-west-3" // EU (Paris).+ SaEast1RegionID = "sa-east-1" // South America (Sao Paulo).+ UsEast1RegionID = "us-east-1" // US East (N. Virginia).+ UsEast2RegionID = "us-east-2" // US East (Ohio).+ UsWest1RegionID = "us-west-1" // US West (N. California).+ UsWest2RegionID = "us-west-2" // US West (Oregon).+)++// AWS China partition's regions.+const (+ CnNorth1RegionID = "cn-north-1" // China (Beijing).+ CnNorthwest1RegionID = "cn-northwest-1" // China (Ningxia).+)++// AWS GovCloud (US) partition's regions.+const (+ UsGovEast1RegionID = "us-gov-east-1" // AWS GovCloud (US-East).+ UsGovWest1RegionID = "us-gov-west-1" // AWS GovCloud (US).+)++// DefaultResolver returns an Endpoint resolver that will be able+// to resolve endpoints for: AWS Standard, AWS China, and AWS GovCloud (US).+//+// Use DefaultPartitions() to get the list of the default partitions.+func DefaultResolver() Resolver {+ return defaultPartitions+}++// DefaultPartitions returns a list of the partitions the SDK is bundled+// with. The available partitions are: AWS Standard, AWS China, and AWS GovCloud (US).+//+// partitions := endpoints.DefaultPartitions+// for _, p := range partitions {+// // ... inspect partitions+// }+func DefaultPartitions() []Partition {+ return defaultPartitions.Partitions()+}++var defaultPartitions = partitions{+ awsPartition,+ awscnPartition,+ awsusgovPartition,+}++// AwsPartition returns the Resolver for AWS Standard.+func AwsPartition() Partition {+ return awsPartition.Partition()+}++var awsPartition = partition{+ ID: "aws",+ Name: "AWS Standard",+ DNSSuffix: "amazonaws.com",+ RegionRegex: regionRegex{+ Regexp: func() *regexp.Regexp {+ reg, _ := regexp.Compile("^(us|eu|ap|sa|ca)\\-\\w+\\-\\d+$")+ return reg+ }(),+ },+ Defaults: endpoint{+ Hostname: "{service}.{region}.{dnsSuffix}",+ Protocols: []string{"https"},+ SignatureVersions: []string{"v4"},+ },+ Regions: regions{+ "ap-northeast-1": region{+ Description: "Asia Pacific (Tokyo)",+ },+ "ap-northeast-2": region{+ Description: "Asia Pacific (Seoul)",+ },+ "ap-south-1": region{+ Description: "Asia Pacific (Mumbai)",+ },+ "ap-southeast-1": region{+ Description: "Asia Pacific (Singapore)",+ },+ "ap-southeast-2": region{+ Description: "Asia Pacific (Sydney)",+ },+ "ca-central-1": region{+ Description: "Canada (Central)",+ },+ "eu-central-1": region{+ Description: "EU (Frankfurt)",+ },+ "eu-north-1": region{+ Description: "EU (Stockholm)",+ },+ "eu-west-1": region{+ Description: "EU (Ireland)",+ },+ "eu-west-2": region{+ Description: "EU (London)",+ },+ "eu-west-3": region{+ Description: "EU (Paris)",+ },+ "sa-east-1": region{+ Description: "South America (Sao Paulo)",+ },+ "us-east-1": region{+ Description: "US East (N. Virginia)",+ },+ "us-east-2": region{+ Description: "US East (Ohio)",+ },+ "us-west-1": region{+ Description: "US West (N. California)",+ },+ "us-west-2": region{+ Description: "US West (Oregon)",+ },+ },+ Services: services{+ "a4b": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "acm": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "acm-pca": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "api.mediatailor": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ },+ },+ "api.pricing": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "pricing",+ },+ },+ Endpoints: endpoints{+ "ap-south-1": endpoint{},+ "us-east-1": endpoint{},+ },+ },+ "api.sagemaker": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "apigateway": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "application-autoscaling": service{+ Defaults: endpoint{+ Hostname: "autoscaling.{region}.amazonaws.com",+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Service: "application-autoscaling",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "appstream2": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ CredentialScope: credentialScope{+ Service: "appstream",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "appsync": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "athena": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "autoscaling": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "autoscaling-plans": service{+ Defaults: endpoint{+ Hostname: "autoscaling.{region}.amazonaws.com",+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Service: "autoscaling-plans",+ },+ },+ Endpoints: endpoints{+ "ap-southeast-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "batch": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "budgets": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "budgets.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "ce": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "ce.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "chime": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,+ Defaults: endpoint{+ SSLCommonName: "service.chime.aws.amazon.com",+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "service.chime.aws.amazon.com",+ Protocols: []string{"https"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "cloud9": service{++ Endpoints: endpoints{+ "ap-southeast-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "clouddirectory": service{++ Endpoints: endpoints{+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cloudformation": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cloudfront": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "cloudfront.amazonaws.com",+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "cloudhsm": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cloudhsmv2": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "cloudhsm",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cloudsearch": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cloudtrail": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "codebuild": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "codebuild-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "codebuild-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{},+ "us-west-1-fips": endpoint{+ Hostname: "codebuild-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "codebuild-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "codecommit": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "fips": endpoint{+ Hostname: "codecommit-fips.ca-central-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "ca-central-1",+ },+ },+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "codedeploy": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "codedeploy-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "codedeploy-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{},+ "us-west-1-fips": endpoint{+ Hostname: "codedeploy-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "codedeploy-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "codepipeline": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "codestar": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cognito-identity": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cognito-idp": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cognito-sync": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "comprehend": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "config": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "cur": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "datapipeline": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "dax": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "devicefarm": service{++ Endpoints: endpoints{+ "us-west-2": endpoint{},+ },+ },+ "directconnect": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "discovery": service{++ Endpoints: endpoints{+ "us-west-2": endpoint{},+ },+ },+ "dms": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "ds": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "dynamodb": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "local": endpoint{+ Hostname: "localhost:8000",+ Protocols: []string{"http"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "ec2": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "ec2metadata": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "169.254.169.254/latest",+ Protocols: []string{"http"},+ },+ },+ },+ "ecr": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "ecs": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elasticache": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "fips": endpoint{+ Hostname: "elasticache-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elasticbeanstalk": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elasticfilesystem": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elasticloadbalancing": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elasticmapreduce": service{+ Defaults: endpoint{+ SSLCommonName: "{region}.{service}.{dnsSuffix}",+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{+ SSLCommonName: "{service}.{region}.{dnsSuffix}",+ },+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{+ SSLCommonName: "{service}.{region}.{dnsSuffix}",+ },+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "elastictranscoder": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "email": service{++ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "entitlement.marketplace": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "aws-marketplace",+ },+ },+ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "es": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "events": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "firehose": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "fms": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "gamelift": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "glacier": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "glue": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "greengrass": service{+ IsRegionalized: boxedTrue,+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "guardduty": service{+ IsRegionalized: boxedTrue,+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "health": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "iam": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "iam.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "importexport": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "importexport.amazonaws.com",+ SignatureVersions: []string{"v2", "v4"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ Service: "IngestionService",+ },+ },+ },+ },+ "inspector": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "iot": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "execute-api",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "iotanalytics": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "kinesis": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "kinesisanalytics": service{++ Endpoints: endpoints{+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "kinesisvideo": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "kms": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "lambda": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "lightsail": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "logs": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "machinelearning": service{++ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ },+ },+ "marketplacecommerceanalytics": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "mediaconvert": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "medialive": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "mediapackage": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "mediastore": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "metering.marketplace": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "aws-marketplace",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "mgh": service{++ Endpoints: endpoints{+ "us-west-2": endpoint{},+ },+ },+ "mobileanalytics": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "models.lex": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "lex",+ },+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "monitoring": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "mturk-requester": service{+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "sandbox": endpoint{+ Hostname: "mturk-requester-sandbox.us-east-1.amazonaws.com",+ },+ "us-east-1": endpoint{},+ },+ },+ "neptune": service{++ Endpoints: endpoints{+ "eu-central-1": endpoint{+ Hostname: "rds.eu-central-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "eu-central-1",+ },+ },+ "eu-west-1": endpoint{+ Hostname: "rds.eu-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "eu-west-1",+ },+ },+ "eu-west-2": endpoint{+ Hostname: "rds.eu-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "eu-west-2",+ },+ },+ "us-east-1": endpoint{+ Hostname: "rds.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{+ Hostname: "rds.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-2": endpoint{+ Hostname: "rds.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "opsworks": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "opsworks-cm": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "organizations": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "organizations.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "pinpoint": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "mobiletargeting",+ },+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "polly": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "rds": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{+ SSLCommonName: "{service}.{dnsSuffix}",+ },+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "redshift": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "rekognition": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "resource-groups": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "robomaker": service{++ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "route53": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "route53.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "route53domains": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "runtime.lex": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "lex",+ },+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "runtime.sagemaker": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "s3": service{+ PartitionEndpoint: "us-east-1",+ IsRegionalized: boxedTrue,+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ SignatureVersions: []string{"s3v4"},++ HasDualStack: boxedTrue,+ DualStackHostname: "{service}.dualstack.{region}.{dnsSuffix}",+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{+ Hostname: "s3.ap-northeast-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{+ Hostname: "s3.ap-southeast-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "ap-southeast-2": endpoint{+ Hostname: "s3.ap-southeast-2.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{+ Hostname: "s3.eu-west-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "s3-external-1": endpoint{+ Hostname: "s3-external-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "sa-east-1": endpoint{+ Hostname: "s3.sa-east-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "us-east-1": endpoint{+ Hostname: "s3.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "us-east-2": endpoint{},+ "us-west-1": endpoint{+ Hostname: "s3.us-west-1.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ "us-west-2": endpoint{+ Hostname: "s3.us-west-2.amazonaws.com",+ SignatureVersions: []string{"s3", "s3v4"},+ },+ },+ },+ "s3-control": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ SignatureVersions: []string{"s3v4"},++ HasDualStack: boxedTrue,+ DualStackHostname: "{service}.dualstack.{region}.{dnsSuffix}",+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{+ Hostname: "s3-control.ap-northeast-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ap-northeast-1",+ },+ },+ "ap-northeast-2": endpoint{+ Hostname: "s3-control.ap-northeast-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ap-northeast-2",+ },+ },+ "ap-south-1": endpoint{+ Hostname: "s3-control.ap-south-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ap-south-1",+ },+ },+ "ap-southeast-1": endpoint{+ Hostname: "s3-control.ap-southeast-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ap-southeast-1",+ },+ },+ "ap-southeast-2": endpoint{+ Hostname: "s3-control.ap-southeast-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ap-southeast-2",+ },+ },+ "ca-central-1": endpoint{+ Hostname: "s3-control.ca-central-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "ca-central-1",+ },+ },+ "eu-central-1": endpoint{+ Hostname: "s3-control.eu-central-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "eu-central-1",+ },+ },+ "eu-north-1": endpoint{+ Hostname: "s3-control.eu-north-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "eu-north-1",+ },+ },+ "eu-west-1": endpoint{+ Hostname: "s3-control.eu-west-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "eu-west-1",+ },+ },+ "eu-west-2": endpoint{+ Hostname: "s3-control.eu-west-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "eu-west-2",+ },+ },+ "eu-west-3": endpoint{+ Hostname: "s3-control.eu-west-3.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "eu-west-3",+ },+ },+ "sa-east-1": endpoint{+ Hostname: "s3-control.sa-east-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "sa-east-1",+ },+ },+ "us-east-1": endpoint{+ Hostname: "s3-control.us-east-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-1-fips": endpoint{+ Hostname: "s3-control-fips.us-east-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{+ Hostname: "s3-control.us-east-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-east-2-fips": endpoint{+ Hostname: "s3-control-fips.us-east-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{+ Hostname: "s3-control.us-west-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-1-fips": endpoint{+ Hostname: "s3-control-fips.us-west-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{+ Hostname: "s3-control.us-west-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ "us-west-2-fips": endpoint{+ Hostname: "s3-control-fips.us-west-2.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "sdb": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ SignatureVersions: []string{"v2"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{+ Hostname: "sdb.amazonaws.com",+ },+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "secretsmanager": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "secretsmanager-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "secretsmanager-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{},+ "us-west-1-fips": endpoint{+ Hostname: "secretsmanager-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "secretsmanager-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "serverlessrepo": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{+ Protocols: []string{"https"},+ },+ "ap-northeast-2": endpoint{+ Protocols: []string{"https"},+ },+ "ap-south-1": endpoint{+ Protocols: []string{"https"},+ },+ "ap-southeast-1": endpoint{+ Protocols: []string{"https"},+ },+ "ap-southeast-2": endpoint{+ Protocols: []string{"https"},+ },+ "ca-central-1": endpoint{+ Protocols: []string{"https"},+ },+ "eu-central-1": endpoint{+ Protocols: []string{"https"},+ },+ "eu-west-1": endpoint{+ Protocols: []string{"https"},+ },+ "eu-west-2": endpoint{+ Protocols: []string{"https"},+ },+ "sa-east-1": endpoint{+ Protocols: []string{"https"},+ },+ "us-east-1": endpoint{+ Protocols: []string{"https"},+ },+ "us-east-2": endpoint{+ Protocols: []string{"https"},+ },+ "us-west-1": endpoint{+ Protocols: []string{"https"},+ },+ "us-west-2": endpoint{+ Protocols: []string{"https"},+ },+ },+ },+ "servicecatalog": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "servicecatalog-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "servicecatalog-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{},+ "us-west-1-fips": endpoint{+ Hostname: "servicecatalog-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "servicecatalog-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "servicediscovery": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "shield": service{+ IsRegionalized: boxedFalse,+ Defaults: endpoint{+ SSLCommonName: "Shield.us-east-1.amazonaws.com",+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "sms": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "snowball": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "sns": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "sqs": service{+ Defaults: endpoint{+ SSLCommonName: "{region}.queue.{dnsSuffix}",+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "fips-us-east-1": endpoint{+ Hostname: "sqs-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "fips-us-east-2": endpoint{+ Hostname: "sqs-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "fips-us-west-1": endpoint{+ Hostname: "sqs-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "fips-us-west-2": endpoint{+ Hostname: "sqs-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{+ SSLCommonName: "queue.{dnsSuffix}",+ },+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "ssm": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "states": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "storagegateway": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "streams.dynamodb": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Service: "dynamodb",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "local": endpoint{+ Hostname: "localhost:8000",+ Protocols: []string{"http"},+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "sts": service{+ PartitionEndpoint: "aws-global",+ Defaults: endpoint{+ Hostname: "sts.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{+ Hostname: "sts.ap-northeast-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "ap-northeast-2",+ },+ },+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "aws-global": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "sts-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "sts-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-1": endpoint{},+ "us-west-1-fips": endpoint{+ Hostname: "sts-fips.us-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-1",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "sts-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "support": service{++ Endpoints: endpoints{+ "us-east-1": endpoint{},+ },+ },+ "swf": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "tagging": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "transfer": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "translate": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-1-fips": endpoint{+ Hostname: "translate-fips.us-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ "us-east-2": endpoint{},+ "us-east-2-fips": endpoint{+ Hostname: "translate-fips.us-east-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-2",+ },+ },+ "us-west-2": endpoint{},+ "us-west-2-fips": endpoint{+ Hostname: "translate-fips.us-west-2.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-west-2",+ },+ },+ },+ },+ "waf": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "waf.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-east-1",+ },+ },+ },+ },+ "waf-regional": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "workdocs": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "workmail": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "workspaces": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ "xray": service{++ Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},+ "ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},+ "eu-north-1": endpoint{},+ "eu-west-1": endpoint{},+ "eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-1": endpoint{},+ "us-west-2": endpoint{},+ },+ },+ },+}++// AwsCnPartition returns the Resolver for AWS China.+func AwsCnPartition() Partition {+ return awscnPartition.Partition()+}++var awscnPartition = partition{+ ID: "aws-cn",+ Name: "AWS China",+ DNSSuffix: "amazonaws.com.cn",+ RegionRegex: regionRegex{+ Regexp: func() *regexp.Regexp {+ reg, _ := regexp.Compile("^cn\\-\\w+\\-\\d+$")+ return reg+ }(),+ },+ Defaults: endpoint{+ Hostname: "{service}.{region}.{dnsSuffix}",+ Protocols: []string{"https"},+ SignatureVersions: []string{"v4"},+ },+ Regions: regions{+ "cn-north-1": region{+ Description: "China (Beijing)",+ },+ "cn-northwest-1": region{+ Description: "China (Ningxia)",+ },+ },+ Services: services{+ "apigateway": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "application-autoscaling": service{+ Defaults: endpoint{+ Hostname: "autoscaling.{region}.amazonaws.com.cn",+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Service: "application-autoscaling",+ },+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "autoscaling": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "cloudformation": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "cloudtrail": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "codebuild": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "codedeploy": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "cognito-identity": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ },+ },+ "config": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "directconnect": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "dms": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "ds": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "dynamodb": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "ec2": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "ec2metadata": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "169.254.169.254/latest",+ Protocols: []string{"http"},+ },+ },+ },+ "ecr": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "ecs": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "elasticache": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "elasticbeanstalk": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "elasticloadbalancing": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "elasticmapreduce": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "es": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "events": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "glacier": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "iam": service{+ PartitionEndpoint: "aws-cn-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-cn-global": endpoint{+ Hostname: "iam.cn-north-1.amazonaws.com.cn",+ CredentialScope: credentialScope{+ Region: "cn-north-1",+ },+ },+ },+ },+ "iot": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "execute-api",+ },+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ },+ },+ "kinesis": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "lambda": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "logs": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "monitoring": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "polly": service{++ Endpoints: endpoints{+ "cn-northwest-1": endpoint{},+ },+ },+ "rds": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "redshift": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "s3": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ SignatureVersions: []string{"s3v4"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "s3-control": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ SignatureVersions: []string{"s3v4"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{+ Hostname: "s3-control.cn-north-1.amazonaws.com.cn",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "cn-north-1",+ },+ },+ "cn-northwest-1": endpoint{+ Hostname: "s3-control.cn-northwest-1.amazonaws.com.cn",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "cn-northwest-1",+ },+ },+ },+ },+ "sms": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "snowball": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ },+ },+ "sns": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "sqs": service{+ Defaults: endpoint{+ SSLCommonName: "{region}.queue.{dnsSuffix}",+ Protocols: []string{"http", "https"},+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "ssm": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "storagegateway": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ },+ },+ "streams.dynamodb": service{+ Defaults: endpoint{+ Protocols: []string{"http", "https"},+ CredentialScope: credentialScope{+ Service: "dynamodb",+ },+ },+ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "sts": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "swf": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ "tagging": service{++ Endpoints: endpoints{+ "cn-north-1": endpoint{},+ "cn-northwest-1": endpoint{},+ },+ },+ },+}++// AwsUsGovPartition returns the Resolver for AWS GovCloud (US).+func AwsUsGovPartition() Partition {+ return awsusgovPartition.Partition()+}++var awsusgovPartition = partition{+ ID: "aws-us-gov",+ Name: "AWS GovCloud (US)",+ DNSSuffix: "amazonaws.com",+ RegionRegex: regionRegex{+ Regexp: func() *regexp.Regexp {+ reg, _ := regexp.Compile("^us\\-gov\\-\\w+\\-\\d+$")+ return reg+ }(),+ },+ Defaults: endpoint{+ Hostname: "{service}.{region}.{dnsSuffix}",+ Protocols: []string{"https"},+ SignatureVersions: []string{"v4"},+ },+ Regions: regions{+ "us-gov-east-1": region{+ Description: "AWS GovCloud (US-East)",+ },+ "us-gov-west-1": region{+ Description: "AWS GovCloud (US)",+ },+ },+ Services: services{+ "acm": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "api.sagemaker": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "apigateway": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "application-autoscaling": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "autoscaling": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ Protocols: []string{"http", "https"},+ },+ },+ },+ "clouddirectory": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "cloudformation": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "cloudhsm": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "cloudhsmv2": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "cloudhsm",+ },+ },+ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "cloudtrail": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "codedeploy": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-east-1-fips": endpoint{+ Hostname: "codedeploy-fips.us-gov-east-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-east-1",+ },+ },+ "us-gov-west-1": endpoint{},+ "us-gov-west-1-fips": endpoint{+ Hostname: "codedeploy-fips.us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ "config": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "directconnect": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "dms": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "dynamodb": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ "us-gov-west-1-fips": endpoint{+ Hostname: "dynamodb.us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ "ec2": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "ec2metadata": service{+ PartitionEndpoint: "aws-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-global": endpoint{+ Hostname: "169.254.169.254/latest",+ Protocols: []string{"http"},+ },+ },+ },+ "ecr": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "ecs": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "elasticache": service{++ Endpoints: endpoints{+ "fips": endpoint{+ Hostname: "elasticache-fips.us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "elasticbeanstalk": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "elasticloadbalancing": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ Protocols: []string{"http", "https"},+ },+ },+ },+ "elasticmapreduce": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ Protocols: []string{"https"},+ },+ },+ },+ "es": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "events": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "glacier": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ Protocols: []string{"http", "https"},+ },+ },+ },+ "guardduty": service{+ IsRegionalized: boxedTrue,+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "iam": service{+ PartitionEndpoint: "aws-us-gov-global",+ IsRegionalized: boxedFalse,++ Endpoints: endpoints{+ "aws-us-gov-global": endpoint{+ Hostname: "iam.us-gov.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ "inspector": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "iot": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "execute-api",+ },+ },+ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "kinesis": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "kms": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "lambda": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "logs": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "metering.marketplace": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "aws-marketplace",+ },+ },+ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "monitoring": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "polly": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "rds": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "redshift": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "rekognition": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "runtime.sagemaker": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "s3": service{+ Defaults: endpoint{+ SignatureVersions: []string{"s3", "s3v4"},+ },+ Endpoints: endpoints{+ "fips-us-gov-west-1": endpoint{+ Hostname: "s3-fips-us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ "us-gov-east-1": endpoint{+ Hostname: "s3.us-gov-east-1.amazonaws.com",+ Protocols: []string{"http", "https"},+ },+ "us-gov-west-1": endpoint{+ Hostname: "s3.us-gov-west-1.amazonaws.com",+ Protocols: []string{"http", "https"},+ },+ },+ },+ "s3-control": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ SignatureVersions: []string{"s3v4"},+ },+ Endpoints: endpoints{+ "us-gov-east-1": endpoint{+ Hostname: "s3-control.us-gov-east-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-gov-east-1",+ },+ },+ "us-gov-east-1-fips": endpoint{+ Hostname: "s3-control-fips.us-gov-east-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-gov-east-1",+ },+ },+ "us-gov-west-1": endpoint{+ Hostname: "s3-control.us-gov-west-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ "us-gov-west-1-fips": endpoint{+ Hostname: "s3-control-fips.us-gov-west-1.amazonaws.com",+ SignatureVersions: []string{"s3v4"},+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ "sms": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "snowball": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "sns": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ Protocols: []string{"http", "https"},+ },+ },+ },+ "sqs": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{+ SSLCommonName: "{region}.queue.{dnsSuffix}",+ Protocols: []string{"http", "https"},+ },+ },+ },+ "ssm": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "states": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "storagegateway": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },+ "streams.dynamodb": service{+ Defaults: endpoint{+ CredentialScope: credentialScope{+ Service: "dynamodb",+ },+ },+ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ "us-gov-west-1-fips": endpoint{+ Hostname: "dynamodb.us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ "sts": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "swf": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "tagging": service{++ Endpoints: endpoints{+ "us-gov-east-1": endpoint{},+ "us-gov-west-1": endpoint{},+ },+ },+ "translate": service{+ Defaults: endpoint{+ Protocols: []string{"https"},+ },+ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ "us-gov-west-1-fips": endpoint{+ Hostname: "translate-fips.us-gov-west-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "us-gov-west-1",+ },+ },+ },+ },+ },+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/dep_service_ids.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/dep_service_ids.gonew file mode 100644index 000000000..000dd79ee--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/dep_service_ids.go@@ -0,0 +1,141 @@+package endpoints++// Service identifiers+//+// Deprecated: Use client package's EndpointID value instead of these+// ServiceIDs. These IDs are not maintained, and are out of date.+const (+ A4bServiceID = "a4b" // A4b.+ AcmServiceID = "acm" // Acm.+ AcmPcaServiceID = "acm-pca" // AcmPca.+ ApiMediatailorServiceID = "api.mediatailor" // ApiMediatailor.+ ApiPricingServiceID = "api.pricing" // ApiPricing.+ ApiSagemakerServiceID = "api.sagemaker" // ApiSagemaker.+ ApigatewayServiceID = "apigateway" // Apigateway.+ ApplicationAutoscalingServiceID = "application-autoscaling" // ApplicationAutoscaling.+ Appstream2ServiceID = "appstream2" // Appstream2.+ AppsyncServiceID = "appsync" // Appsync.+ AthenaServiceID = "athena" // Athena.+ AutoscalingServiceID = "autoscaling" // Autoscaling.+ AutoscalingPlansServiceID = "autoscaling-plans" // AutoscalingPlans.+ BatchServiceID = "batch" // Batch.+ BudgetsServiceID = "budgets" // Budgets.+ CeServiceID = "ce" // Ce.+ ChimeServiceID = "chime" // Chime.+ Cloud9ServiceID = "cloud9" // Cloud9.+ ClouddirectoryServiceID = "clouddirectory" // Clouddirectory.+ CloudformationServiceID = "cloudformation" // Cloudformation.+ CloudfrontServiceID = "cloudfront" // Cloudfront.+ CloudhsmServiceID = "cloudhsm" // Cloudhsm.+ Cloudhsmv2ServiceID = "cloudhsmv2" // Cloudhsmv2.+ CloudsearchServiceID = "cloudsearch" // Cloudsearch.+ CloudtrailServiceID = "cloudtrail" // Cloudtrail.+ CodebuildServiceID = "codebuild" // Codebuild.+ CodecommitServiceID = "codecommit" // Codecommit.+ CodedeployServiceID = "codedeploy" // Codedeploy.+ CodepipelineServiceID = "codepipeline" // Codepipeline.+ CodestarServiceID = "codestar" // Codestar.+ CognitoIdentityServiceID = "cognito-identity" // CognitoIdentity.+ CognitoIdpServiceID = "cognito-idp" // CognitoIdp.+ CognitoSyncServiceID = "cognito-sync" // CognitoSync.+ ComprehendServiceID = "comprehend" // Comprehend.+ ConfigServiceID = "config" // Config.+ CurServiceID = "cur" // Cur.+ DatapipelineServiceID = "datapipeline" // Datapipeline.+ DaxServiceID = "dax" // Dax.+ DevicefarmServiceID = "devicefarm" // Devicefarm.+ DirectconnectServiceID = "directconnect" // Directconnect.+ DiscoveryServiceID = "discovery" // Discovery.+ DmsServiceID = "dms" // Dms.+ DsServiceID = "ds" // Ds.+ DynamodbServiceID = "dynamodb" // Dynamodb.+ Ec2ServiceID = "ec2" // Ec2.+ Ec2metadataServiceID = "ec2metadata" // Ec2metadata.+ EcrServiceID = "ecr" // Ecr.+ EcsServiceID = "ecs" // Ecs.+ ElasticacheServiceID = "elasticache" // Elasticache.+ ElasticbeanstalkServiceID = "elasticbeanstalk" // Elasticbeanstalk.+ ElasticfilesystemServiceID = "elasticfilesystem" // Elasticfilesystem.+ ElasticloadbalancingServiceID = "elasticloadbalancing" // Elasticloadbalancing.+ ElasticmapreduceServiceID = "elasticmapreduce" // Elasticmapreduce.+ ElastictranscoderServiceID = "elastictranscoder" // Elastictranscoder.+ EmailServiceID = "email" // Email.+ EntitlementMarketplaceServiceID = "entitlement.marketplace" // EntitlementMarketplace.+ EsServiceID = "es" // Es.+ EventsServiceID = "events" // Events.+ FirehoseServiceID = "firehose" // Firehose.+ FmsServiceID = "fms" // Fms.+ GameliftServiceID = "gamelift" // Gamelift.+ GlacierServiceID = "glacier" // Glacier.+ GlueServiceID = "glue" // Glue.+ GreengrassServiceID = "greengrass" // Greengrass.+ GuarddutyServiceID = "guardduty" // Guardduty.+ HealthServiceID = "health" // Health.+ IamServiceID = "iam" // Iam.+ ImportexportServiceID = "importexport" // Importexport.+ InspectorServiceID = "inspector" // Inspector.+ IotServiceID = "iot" // Iot.+ IotanalyticsServiceID = "iotanalytics" // Iotanalytics.+ KinesisServiceID = "kinesis" // Kinesis.+ KinesisanalyticsServiceID = "kinesisanalytics" // Kinesisanalytics.+ KinesisvideoServiceID = "kinesisvideo" // Kinesisvideo.+ KmsServiceID = "kms" // Kms.+ LambdaServiceID = "lambda" // Lambda.+ LightsailServiceID = "lightsail" // Lightsail.+ LogsServiceID = "logs" // Logs.+ MachinelearningServiceID = "machinelearning" // Machinelearning.+ MarketplacecommerceanalyticsServiceID = "marketplacecommerceanalytics" // Marketplacecommerceanalytics.+ MediaconvertServiceID = "mediaconvert" // Mediaconvert.+ MedialiveServiceID = "medialive" // Medialive.+ MediapackageServiceID = "mediapackage" // Mediapackage.+ MediastoreServiceID = "mediastore" // Mediastore.+ MeteringMarketplaceServiceID = "metering.marketplace" // MeteringMarketplace.+ MghServiceID = "mgh" // Mgh.+ MobileanalyticsServiceID = "mobileanalytics" // Mobileanalytics.+ ModelsLexServiceID = "models.lex" // ModelsLex.+ MonitoringServiceID = "monitoring" // Monitoring.+ MturkRequesterServiceID = "mturk-requester" // MturkRequester.+ NeptuneServiceID = "neptune" // Neptune.+ OpsworksServiceID = "opsworks" // Opsworks.+ OpsworksCmServiceID = "opsworks-cm" // OpsworksCm.+ OrganizationsServiceID = "organizations" // Organizations.+ PinpointServiceID = "pinpoint" // Pinpoint.+ PollyServiceID = "polly" // Polly.+ RdsServiceID = "rds" // Rds.+ RedshiftServiceID = "redshift" // Redshift.+ RekognitionServiceID = "rekognition" // Rekognition.+ ResourceGroupsServiceID = "resource-groups" // ResourceGroups.+ Route53ServiceID = "route53" // Route53.+ Route53domainsServiceID = "route53domains" // Route53domains.+ RuntimeLexServiceID = "runtime.lex" // RuntimeLex.+ RuntimeSagemakerServiceID = "runtime.sagemaker" // RuntimeSagemaker.+ S3ServiceID = "s3" // S3.+ S3ControlServiceID = "s3-control" // S3Control.+ SagemakerServiceID = "api.sagemaker" // Sagemaker.+ SdbServiceID = "sdb" // Sdb.+ SecretsmanagerServiceID = "secretsmanager" // Secretsmanager.+ ServerlessrepoServiceID = "serverlessrepo" // Serverlessrepo.+ ServicecatalogServiceID = "servicecatalog" // Servicecatalog.+ ServicediscoveryServiceID = "servicediscovery" // Servicediscovery.+ ShieldServiceID = "shield" // Shield.+ SmsServiceID = "sms" // Sms.+ SnowballServiceID = "snowball" // Snowball.+ SnsServiceID = "sns" // Sns.+ SqsServiceID = "sqs" // Sqs.+ SsmServiceID = "ssm" // Ssm.+ StatesServiceID = "states" // States.+ StoragegatewayServiceID = "storagegateway" // Storagegateway.+ StreamsDynamodbServiceID = "streams.dynamodb" // StreamsDynamodb.+ StsServiceID = "sts" // Sts.+ SupportServiceID = "support" // Support.+ SwfServiceID = "swf" // Swf.+ TaggingServiceID = "tagging" // Tagging.+ TransferServiceID = "transfer" // Transfer.+ TranslateServiceID = "translate" // Translate.+ WafServiceID = "waf" // Waf.+ WafRegionalServiceID = "waf-regional" // WafRegional.+ WorkdocsServiceID = "workdocs" // Workdocs.+ WorkmailServiceID = "workmail" // Workmail.+ WorkspacesServiceID = "workspaces" // Workspaces.+ XrayServiceID = "xray" // Xray.+)diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.gonew file mode 100644index 000000000..84316b92c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/doc.go@@ -0,0 +1,66 @@+// Package endpoints provides the types and functionality for defining regions+// and endpoints, as well as querying those definitions.+//+// The SDK's Regions and Endpoints metadata is code generated into the endpoints+// package, and is accessible via the DefaultResolver function. This function+// returns a endpoint Resolver will search the metadata and build an associated+// endpoint if one is found. The default resolver will search all partitions+// known by the SDK. e.g AWS Standard (aws), AWS China (aws-cn), and+// AWS GovCloud (US) (aws-us-gov).+// .+//+// Enumerating Regions and Endpoint Metadata+//+// Casting the Resolver returned by DefaultResolver to a EnumPartitions interface+// will allow you to get access to the list of underlying Partitions with the+// Partitions method. This is helpful if you want to limit the SDK's endpoint+// resolving to a single partition, or enumerate regions, services, and endpoints+// in the partition.+//+// resolver := endpoints.DefaultResolver()+// partitions := resolver.(endpoints.EnumPartitions).Partitions()+//+// for _, p := range partitions {+// fmt.Println("Regions for", p.ID())+// for id, _ := range p.Regions() {+// fmt.Println("*", id)+// }+//+// fmt.Println("Services for", p.ID())+// for id, _ := range p.Services() {+// fmt.Println("*", id)+// }+// }+//+// Using Custom Endpoints+//+// The endpoints package also gives you the ability to use your own logic how+// endpoints are resolved. This is a great way to define a custom endpoint+// for select services, without passing that logic down through your code.+//+// If a type implements the Resolver interface it can be used to resolve+// endpoints. To use this with the SDK's Session and Config set the value+// of the type to the EndpointsResolver field of aws.Config when initializing+// the session, or service client.+//+// In addition the ResolverFunc is a wrapper for a func matching the signature+// of Resolver.EndpointFor, converting it to a type that satisfies the+// Resolver interface.+//+//+// myCustomResolver := func(service, region string, optFns ...func(*endpoints.Options)) (endpoints.ResolvedEndpoint, error) {+// if service == endpoints.S3ServiceID {+// return endpoints.ResolvedEndpoint{+// URL: "s3.custom.endpoint.com",+// SigningRegion: "custom-signing-region",+// }, nil+// }+//+// return endpoints.DefaultResolver().EndpointFor(service, region, optFns...)+// }+//+// sess := session.Must(session.NewSession(&aws.Config{+// Region: aws.String("us-west-2"),+// EndpointResolver: endpoints.ResolverFunc(myCustomResolver),+// }))+package endpointsdiff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.gonew file mode 100644index 000000000..e29c09512--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/endpoints.go@@ -0,0 +1,449 @@+package endpoints++import (+ "fmt"+ "regexp"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++// Options provide the configuration needed to direct how the+// endpoints will be resolved.+type Options struct {+ // DisableSSL forces the endpoint to be resolved as HTTP.+ // instead of HTTPS if the service supports it.+ DisableSSL bool++ // Sets the resolver to resolve the endpoint as a dualstack endpoint+ // for the service. If dualstack support for a service is not known and+ // StrictMatching is not enabled a dualstack endpoint for the service will+ // be returned. This endpoint may not be valid. If StrictMatching is+ // enabled only services that are known to support dualstack will return+ // dualstack endpoints.+ UseDualStack bool++ // Enables strict matching of services and regions resolved endpoints.+ // If the partition doesn't enumerate the exact service and region an+ // error will be returned. This option will prevent returning endpoints+ // that look valid, but may not resolve to any real endpoint.+ StrictMatching bool++ // Enables resolving a service endpoint based on the region provided if the+ // service does not exist. The service endpoint ID will be used as the service+ // domain name prefix. By default the endpoint resolver requires the service+ // to be known when resolving endpoints.+ //+ // If resolving an endpoint on the partition list the provided region will+ // be used to determine which partition's domain name pattern to the service+ // endpoint ID with. If both the service and region are unkonwn and resolving+ // the endpoint on partition list an UnknownEndpointError error will be returned.+ //+ // If resolving and endpoint on a partition specific resolver that partition's+ // domain name pattern will be used with the service endpoint ID. If both+ // region and service do not exist when resolving an endpoint on a specific+ // partition the partition's domain pattern will be used to combine the+ // endpoint and region together.+ //+ // This option is ignored if StrictMatching is enabled.+ ResolveUnknownService bool+}++// Set combines all of the option functions together.+func (o *Options) Set(optFns ...func(*Options)) {+ for _, fn := range optFns {+ fn(o)+ }+}++// DisableSSLOption sets the DisableSSL options. Can be used as a functional+// option when resolving endpoints.+func DisableSSLOption(o *Options) {+ o.DisableSSL = true+}++// UseDualStackOption sets the UseDualStack option. Can be used as a functional+// option when resolving endpoints.+func UseDualStackOption(o *Options) {+ o.UseDualStack = true+}++// StrictMatchingOption sets the StrictMatching option. Can be used as a functional+// option when resolving endpoints.+func StrictMatchingOption(o *Options) {+ o.StrictMatching = true+}++// ResolveUnknownServiceOption sets the ResolveUnknownService option. Can be used+// as a functional option when resolving endpoints.+func ResolveUnknownServiceOption(o *Options) {+ o.ResolveUnknownService = true+}++// A Resolver provides the interface for functionality to resolve endpoints.+// The build in Partition and DefaultResolver return value satisfy this interface.+type Resolver interface {+ EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error)+}++// ResolverFunc is a helper utility that wraps a function so it satisfies the+// Resolver interface. This is useful when you want to add additional endpoint+// resolving logic, or stub out specific endpoints with custom values.+type ResolverFunc func(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error)++// EndpointFor wraps the ResolverFunc function to satisfy the Resolver interface.+func (fn ResolverFunc) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {+ return fn(service, region, opts...)+}++var schemeRE = regexp.MustCompile("^([^:]+)://")++// AddScheme adds the HTTP or HTTPS schemes to a endpoint URL if there is no+// scheme. If disableSSL is true HTTP will set HTTP instead of the default HTTPS.+//+// If disableSSL is set, it will only set the URL's scheme if the URL does not+// contain a scheme.+func AddScheme(endpoint string, disableSSL bool) string {+ if !schemeRE.MatchString(endpoint) {+ scheme := "https"+ if disableSSL {+ scheme = "http"+ }+ endpoint = fmt.Sprintf("%s://%s", scheme, endpoint)+ }++ return endpoint+}++// EnumPartitions a provides a way to retrieve the underlying partitions that+// make up the SDK's default Resolver, or any resolver decoded from a model+// file.+//+// Use this interface with DefaultResolver and DecodeModels to get the list of+// Partitions.+type EnumPartitions interface {+ Partitions() []Partition+}++// RegionsForService returns a map of regions for the partition and service.+// If either the partition or service does not exist false will be returned+// as the second parameter.+//+// This example shows how to get the regions for DynamoDB in the AWS partition.+// rs, exists := endpoints.RegionsForService(endpoints.DefaultPartitions(), endpoints.AwsPartitionID, endpoints.DynamodbServiceID)+//+// This is equivalent to using the partition directly.+// rs := endpoints.AwsPartition().Services()[endpoints.DynamodbServiceID].Regions()+func RegionsForService(ps []Partition, partitionID, serviceID string) (map[string]Region, bool) {+ for _, p := range ps {+ if p.ID() != partitionID {+ continue+ }+ if _, ok := p.p.Services[serviceID]; !ok {+ break+ }++ s := Service{+ id: serviceID,+ p: p.p,+ }+ return s.Regions(), true+ }++ return map[string]Region{}, false+}++// PartitionForRegion returns the first partition which includes the region+// passed in. This includes both known regions and regions which match+// a pattern supported by the partition which may include regions that are+// not explicitly known by the partition. Use the Regions method of the+// returned Partition if explicit support is needed.+func PartitionForRegion(ps []Partition, regionID string) (Partition, bool) {+ for _, p := range ps {+ if _, ok := p.p.Regions[regionID]; ok || p.p.RegionRegex.MatchString(regionID) {+ return p, true+ }+ }++ return Partition{}, false+}++// A Partition provides the ability to enumerate the partition's regions+// and services.+type Partition struct {+ id string+ p *partition+}++// ID returns the identifier of the partition.+func (p Partition) ID() string { return p.id }++// EndpointFor attempts to resolve the endpoint based on service and region.+// See Options for information on configuring how the endpoint is resolved.+//+// If the service cannot be found in the metadata the UnknownServiceError+// error will be returned. This validation will occur regardless if+// StrictMatching is enabled. To enable resolving unknown services set the+// "ResolveUnknownService" option to true. When StrictMatching is disabled+// this option allows the partition resolver to resolve a endpoint based on+// the service endpoint ID provided.+//+// When resolving endpoints you can choose to enable StrictMatching. This will+// require the provided service and region to be known by the partition.+// If the endpoint cannot be strictly resolved an error will be returned. This+// mode is useful to ensure the endpoint resolved is valid. Without+// StrictMatching enabled the endpoint returned my look valid but may not work.+// StrictMatching requires the SDK to be updated if you want to take advantage+// of new regions and services expansions.+//+// Errors that can be returned.+// * UnknownServiceError+// * UnknownEndpointError+func (p Partition) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {+ return p.p.EndpointFor(service, region, opts...)+}++// Regions returns a map of Regions indexed by their ID. This is useful for+// enumerating over the regions in a partition.+func (p Partition) Regions() map[string]Region {+ rs := map[string]Region{}+ for id, r := range p.p.Regions {+ rs[id] = Region{+ id: id,+ desc: r.Description,+ p: p.p,+ }+ }++ return rs+}++// Services returns a map of Service indexed by their ID. This is useful for+// enumerating over the services in a partition.+func (p Partition) Services() map[string]Service {+ ss := map[string]Service{}+ for id := range p.p.Services {+ ss[id] = Service{+ id: id,+ p: p.p,+ }+ }++ return ss+}++// A Region provides information about a region, and ability to resolve an+// endpoint from the context of a region, given a service.+type Region struct {+ id, desc string+ p *partition+}++// ID returns the region's identifier.+func (r Region) ID() string { return r.id }++// Description returns the region's description. The region description+// is free text, it can be empty, and it may change between SDK releases.+func (r Region) Description() string { return r.desc }++// ResolveEndpoint resolves an endpoint from the context of the region given+// a service. See Partition.EndpointFor for usage and errors that can be returned.+func (r Region) ResolveEndpoint(service string, opts ...func(*Options)) (ResolvedEndpoint, error) {+ return r.p.EndpointFor(service, r.id, opts...)+}++// Services returns a list of all services that are known to be in this region.+func (r Region) Services() map[string]Service {+ ss := map[string]Service{}+ for id, s := range r.p.Services {+ if _, ok := s.Endpoints[r.id]; ok {+ ss[id] = Service{+ id: id,+ p: r.p,+ }+ }+ }++ return ss+}++// A Service provides information about a service, and ability to resolve an+// endpoint from the context of a service, given a region.+type Service struct {+ id string+ p *partition+}++// ID returns the identifier for the service.+func (s Service) ID() string { return s.id }++// ResolveEndpoint resolves an endpoint from the context of a service given+// a region. See Partition.EndpointFor for usage and errors that can be returned.+func (s Service) ResolveEndpoint(region string, opts ...func(*Options)) (ResolvedEndpoint, error) {+ return s.p.EndpointFor(s.id, region, opts...)+}++// Regions returns a map of Regions that the service is present in.+//+// A region is the AWS region the service exists in. Whereas a Endpoint is+// an URL that can be resolved to a instance of a service.+func (s Service) Regions() map[string]Region {+ rs := map[string]Region{}+ for id := range s.p.Services[s.id].Endpoints {+ if r, ok := s.p.Regions[id]; ok {+ rs[id] = Region{+ id: id,+ desc: r.Description,+ p: s.p,+ }+ }+ }++ return rs+}++// Endpoints returns a map of Endpoints indexed by their ID for all known+// endpoints for a service.+//+// A region is the AWS region the service exists in. Whereas a Endpoint is+// an URL that can be resolved to a instance of a service.+func (s Service) Endpoints() map[string]Endpoint {+ es := map[string]Endpoint{}+ for id := range s.p.Services[s.id].Endpoints {+ es[id] = Endpoint{+ id: id,+ serviceID: s.id,+ p: s.p,+ }+ }++ return es+}++// A Endpoint provides information about endpoints, and provides the ability+// to resolve that endpoint for the service, and the region the endpoint+// represents.+type Endpoint struct {+ id string+ serviceID string+ p *partition+}++// ID returns the identifier for an endpoint.+func (e Endpoint) ID() string { return e.id }++// ServiceID returns the identifier the endpoint belongs to.+func (e Endpoint) ServiceID() string { return e.serviceID }++// ResolveEndpoint resolves an endpoint from the context of a service and+// region the endpoint represents. See Partition.EndpointFor for usage and+// errors that can be returned.+func (e Endpoint) ResolveEndpoint(opts ...func(*Options)) (ResolvedEndpoint, error) {+ return e.p.EndpointFor(e.serviceID, e.id, opts...)+}++// A ResolvedEndpoint is an endpoint that has been resolved based on a partition+// service, and region.+type ResolvedEndpoint struct {+ // The endpoint URL+ URL string++ // The region that should be used for signing requests.+ SigningRegion string++ // The service name that should be used for signing requests.+ SigningName string++ // States that the signing name for this endpoint was derived from metadata+ // passed in, but was not explicitly modeled.+ SigningNameDerived bool++ // The signing method that should be used for signing requests.+ SigningMethod string+}++// So that the Error interface type can be included as an anonymous field+// in the requestError struct and not conflict with the error.Error() method.+type awsError awserr.Error++// A EndpointNotFoundError is returned when in StrictMatching mode, and the+// endpoint for the service and region cannot be found in any of the partitions.+type EndpointNotFoundError struct {+ awsError+ Partition string+ Service string+ Region string+}++// A UnknownServiceError is returned when the service does not resolve to an+// endpoint. Includes a list of all known services for the partition. Returned+// when a partition does not support the service.+type UnknownServiceError struct {+ awsError+ Partition string+ Service string+ Known []string+}++// NewUnknownServiceError builds and returns UnknownServiceError.+func NewUnknownServiceError(p, s string, known []string) UnknownServiceError {+ return UnknownServiceError{+ awsError: awserr.New("UnknownServiceError",+ "could not resolve endpoint for unknown service", nil),+ Partition: p,+ Service: s,+ Known: known,+ }+}++// String returns the string representation of the error.+func (e UnknownServiceError) Error() string {+ extra := fmt.Sprintf("partition: %q, service: %q",+ e.Partition, e.Service)+ if len(e.Known) > 0 {+ extra += fmt.Sprintf(", known: %v", e.Known)+ }+ return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())+}++// String returns the string representation of the error.+func (e UnknownServiceError) String() string {+ return e.Error()+}++// A UnknownEndpointError is returned when in StrictMatching mode and the+// service is valid, but the region does not resolve to an endpoint. Includes+// a list of all known endpoints for the service.+type UnknownEndpointError struct {+ awsError+ Partition string+ Service string+ Region string+ Known []string+}++// NewUnknownEndpointError builds and returns UnknownEndpointError.+func NewUnknownEndpointError(p, s, r string, known []string) UnknownEndpointError {+ return UnknownEndpointError{+ awsError: awserr.New("UnknownEndpointError",+ "could not resolve endpoint", nil),+ Partition: p,+ Service: s,+ Region: r,+ Known: known,+ }+}++// String returns the string representation of the error.+func (e UnknownEndpointError) Error() string {+ extra := fmt.Sprintf("partition: %q, service: %q, region: %q",+ e.Partition, e.Service, e.Region)+ if len(e.Known) > 0 {+ extra += fmt.Sprintf(", known: %v", e.Known)+ }+ return awserr.SprintError(e.Code(), e.Message(), extra, e.OrigErr())+}++// String returns the string representation of the error.+func (e UnknownEndpointError) String() string {+ return e.Error()+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.gonew file mode 100644index 000000000..ff6f76db6--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model.go@@ -0,0 +1,307 @@+package endpoints++import (+ "fmt"+ "regexp"+ "strconv"+ "strings"+)++type partitions []partition++func (ps partitions) EndpointFor(service, region string, opts ...func(*Options)) (ResolvedEndpoint, error) {+ var opt Options+ opt.Set(opts...)++ for i := 0; i < len(ps); i++ {+ if !ps[i].canResolveEndpoint(service, region, opt.StrictMatching) {+ continue+ }++ return ps[i].EndpointFor(service, region, opts...)+ }++ // If loose matching fallback to first partition format to use+ // when resolving the endpoint.+ if !opt.StrictMatching && len(ps) > 0 {+ return ps[0].EndpointFor(service, region, opts...)+ }++ return ResolvedEndpoint{}, NewUnknownEndpointError("all partitions", service, region, []string{})+}++// Partitions satisfies the EnumPartitions interface and returns a list+// of Partitions representing each partition represented in the SDK's+// endpoints model.+func (ps partitions) Partitions() []Partition {+ parts := make([]Partition, 0, len(ps))+ for i := 0; i < len(ps); i++ {+ parts = append(parts, ps[i].Partition())+ }++ return parts+}++type partition struct {+ ID string `json:"partition"`+ Name string `json:"partitionName"`+ DNSSuffix string `json:"dnsSuffix"`+ RegionRegex regionRegex `json:"regionRegex"`+ Defaults endpoint `json:"defaults"`+ Regions regions `json:"regions"`+ Services services `json:"services"`+}++func (p partition) Partition() Partition {+ return Partition{+ id: p.ID,+ p: &p,+ }+}++func (p partition) canResolveEndpoint(service, region string, strictMatch bool) bool {+ s, hasService := p.Services[service]+ _, hasEndpoint := s.Endpoints[region]++ if hasEndpoint && hasService {+ return true+ }++ if strictMatch {+ return false+ }++ return p.RegionRegex.MatchString(region)+}++func (p partition) EndpointFor(service, region string, opts ...func(*Options)) (resolved ResolvedEndpoint, err error) {+ var opt Options+ opt.Set(opts...)++ s, hasService := p.Services[service]+ if !(hasService || opt.ResolveUnknownService) {+ // Only return error if the resolver will not fallback to creating+ // endpoint based on service endpoint ID passed in.+ return resolved, NewUnknownServiceError(p.ID, service, serviceList(p.Services))+ }++ e, hasEndpoint := s.endpointForRegion(region)+ if !hasEndpoint && opt.StrictMatching {+ return resolved, NewUnknownEndpointError(p.ID, service, region, endpointList(s.Endpoints))+ }++ defs := []endpoint{p.Defaults, s.Defaults}+ return e.resolve(service, region, p.DNSSuffix, defs, opt), nil+}++func serviceList(ss services) []string {+ list := make([]string, 0, len(ss))+ for k := range ss {+ list = append(list, k)+ }+ return list+}+func endpointList(es endpoints) []string {+ list := make([]string, 0, len(es))+ for k := range es {+ list = append(list, k)+ }+ return list+}++type regionRegex struct {+ *regexp.Regexp+}++func (rr *regionRegex) UnmarshalJSON(b []byte) (err error) {+ // Strip leading and trailing quotes+ regex, err := strconv.Unquote(string(b))+ if err != nil {+ return fmt.Errorf("unable to strip quotes from regex, %v", err)+ }++ rr.Regexp, err = regexp.Compile(regex)+ if err != nil {+ return fmt.Errorf("unable to unmarshal region regex, %v", err)+ }+ return nil+}++type regions map[string]region++type region struct {+ Description string `json:"description"`+}++type services map[string]service++type service struct {+ PartitionEndpoint string `json:"partitionEndpoint"`+ IsRegionalized boxedBool `json:"isRegionalized,omitempty"`+ Defaults endpoint `json:"defaults"`+ Endpoints endpoints `json:"endpoints"`+}++func (s *service) endpointForRegion(region string) (endpoint, bool) {+ if s.IsRegionalized == boxedFalse {+ return s.Endpoints[s.PartitionEndpoint], region == s.PartitionEndpoint+ }++ if e, ok := s.Endpoints[region]; ok {+ return e, true+ }++ // Unable to find any matching endpoint, return+ // blank that will be used for generic endpoint creation.+ return endpoint{}, false+}++type endpoints map[string]endpoint++type endpoint struct {+ Hostname string `json:"hostname"`+ Protocols []string `json:"protocols"`+ CredentialScope credentialScope `json:"credentialScope"`++ // Custom fields not modeled+ HasDualStack boxedBool `json:"-"`+ DualStackHostname string `json:"-"`++ // Signature Version not used+ SignatureVersions []string `json:"signatureVersions"`++ // SSLCommonName not used.+ SSLCommonName string `json:"sslCommonName"`+}++const (+ defaultProtocol = "https"+ defaultSigner = "v4"+)++var (+ protocolPriority = []string{"https", "http"}+ signerPriority = []string{"v4", "v2"}+)++func getByPriority(s []string, p []string, def string) string {+ if len(s) == 0 {+ return def+ }++ for i := 0; i < len(p); i++ {+ for j := 0; j < len(s); j++ {+ if s[j] == p[i] {+ return s[j]+ }+ }+ }++ return s[0]+}++func (e endpoint) resolve(service, region, dnsSuffix string, defs []endpoint, opts Options) ResolvedEndpoint {+ var merged endpoint+ for _, def := range defs {+ merged.mergeIn(def)+ }+ merged.mergeIn(e)+ e = merged++ hostname := e.Hostname++ // Offset the hostname for dualstack if enabled+ if opts.UseDualStack && e.HasDualStack == boxedTrue {+ hostname = e.DualStackHostname+ }++ u := strings.Replace(hostname, "{service}", service, 1)+ u = strings.Replace(u, "{region}", region, 1)+ u = strings.Replace(u, "{dnsSuffix}", dnsSuffix, 1)++ scheme := getEndpointScheme(e.Protocols, opts.DisableSSL)+ u = fmt.Sprintf("%s://%s", scheme, u)++ signingRegion := e.CredentialScope.Region+ if len(signingRegion) == 0 {+ signingRegion = region+ }++ signingName := e.CredentialScope.Service+ var signingNameDerived bool+ if len(signingName) == 0 {+ signingName = service+ signingNameDerived = true+ }++ return ResolvedEndpoint{+ URL: u,+ SigningRegion: signingRegion,+ SigningName: signingName,+ SigningNameDerived: signingNameDerived,+ SigningMethod: getByPriority(e.SignatureVersions, signerPriority, defaultSigner),+ }+}++func getEndpointScheme(protocols []string, disableSSL bool) string {+ if disableSSL {+ return "http"+ }++ return getByPriority(protocols, protocolPriority, defaultProtocol)+}++func (e *endpoint) mergeIn(other endpoint) {+ if len(other.Hostname) > 0 {+ e.Hostname = other.Hostname+ }+ if len(other.Protocols) > 0 {+ e.Protocols = other.Protocols+ }+ if len(other.SignatureVersions) > 0 {+ e.SignatureVersions = other.SignatureVersions+ }+ if len(other.CredentialScope.Region) > 0 {+ e.CredentialScope.Region = other.CredentialScope.Region+ }+ if len(other.CredentialScope.Service) > 0 {+ e.CredentialScope.Service = other.CredentialScope.Service+ }+ if len(other.SSLCommonName) > 0 {+ e.SSLCommonName = other.SSLCommonName+ }+ if other.HasDualStack != boxedBoolUnset {+ e.HasDualStack = other.HasDualStack+ }+ if len(other.DualStackHostname) > 0 {+ e.DualStackHostname = other.DualStackHostname+ }+}++type credentialScope struct {+ Region string `json:"region"`+ Service string `json:"service"`+}++type boxedBool int++func (b *boxedBool) UnmarshalJSON(buf []byte) error {+ v, err := strconv.ParseBool(string(buf))+ if err != nil {+ return err+ }++ if v {+ *b = boxedTrue+ } else {+ *b = boxedFalse+ }++ return nil+}++const (+ boxedBoolUnset boxedBool = iota+ boxedFalse+ boxedTrue+)diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.gonew file mode 100644index 000000000..0fdfcc56e--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/v3model_codegen.go@@ -0,0 +1,351 @@+// +build codegen++package endpoints++import (+ "fmt"+ "io"+ "reflect"+ "strings"+ "text/template"+ "unicode"+)++// A CodeGenOptions are the options for code generating the endpoints into+// Go code from the endpoints model definition.+type CodeGenOptions struct {+ // Options for how the model will be decoded.+ DecodeModelOptions DecodeModelOptions++ // Disables code generation of the service endpoint prefix IDs defined in+ // the model.+ DisableGenerateServiceIDs bool+}++// Set combines all of the option functions together+func (d *CodeGenOptions) Set(optFns ...func(*CodeGenOptions)) {+ for _, fn := range optFns {+ fn(d)+ }+}++// CodeGenModel given a endpoints model file will decode it and attempt to+// generate Go code from the model definition. Error will be returned if+// the code is unable to be generated, or decoded.+func CodeGenModel(modelFile io.Reader, outFile io.Writer, optFns ...func(*CodeGenOptions)) error {+ var opts CodeGenOptions+ opts.Set(optFns...)++ resolver, err := DecodeModel(modelFile, func(d *DecodeModelOptions) {+ *d = opts.DecodeModelOptions+ })+ if err != nil {+ return err+ }++ v := struct {+ Resolver+ CodeGenOptions+ }{+ Resolver: resolver,+ CodeGenOptions: opts,+ }++ tmpl := template.Must(template.New("tmpl").Funcs(funcMap).Parse(v3Tmpl))+ if err := tmpl.ExecuteTemplate(outFile, "defaults", v); err != nil {+ return fmt.Errorf("failed to execute template, %v", err)+ }++ return nil+}++func toSymbol(v string) string {+ out := []rune{}+ for _, c := range strings.Title(v) {+ if !(unicode.IsNumber(c) || unicode.IsLetter(c)) {+ continue+ }++ out = append(out, c)+ }++ return string(out)+}++func quoteString(v string) string {+ return fmt.Sprintf("%q", v)+}++func regionConstName(p, r string) string {+ return toSymbol(p) + toSymbol(r)+}++func partitionGetter(id string) string {+ return fmt.Sprintf("%sPartition", toSymbol(id))+}++func partitionVarName(id string) string {+ return fmt.Sprintf("%sPartition", strings.ToLower(toSymbol(id)))+}++func listPartitionNames(ps partitions) string {+ names := []string{}+ switch len(ps) {+ case 1:+ return ps[0].Name+ case 2:+ return fmt.Sprintf("%s and %s", ps[0].Name, ps[1].Name)+ default:+ for i, p := range ps {+ if i == len(ps)-1 {+ names = append(names, "and "+p.Name)+ } else {+ names = append(names, p.Name)+ }+ }+ return strings.Join(names, ", ")+ }+}++func boxedBoolIfSet(msg string, v boxedBool) string {+ switch v {+ case boxedTrue:+ return fmt.Sprintf(msg, "boxedTrue")+ case boxedFalse:+ return fmt.Sprintf(msg, "boxedFalse")+ default:+ return ""+ }+}++func stringIfSet(msg, v string) string {+ if len(v) == 0 {+ return ""+ }++ return fmt.Sprintf(msg, v)+}++func stringSliceIfSet(msg string, vs []string) string {+ if len(vs) == 0 {+ return ""+ }++ names := []string{}+ for _, v := range vs {+ names = append(names, `"`+v+`"`)+ }++ return fmt.Sprintf(msg, strings.Join(names, ","))+}++func endpointIsSet(v endpoint) bool {+ return !reflect.DeepEqual(v, endpoint{})+}++func serviceSet(ps partitions) map[string]struct{} {+ set := map[string]struct{}{}+ for _, p := range ps {+ for id := range p.Services {+ set[id] = struct{}{}+ }+ }++ return set+}++var funcMap = template.FuncMap{+ "ToSymbol": toSymbol,+ "QuoteString": quoteString,+ "RegionConst": regionConstName,+ "PartitionGetter": partitionGetter,+ "PartitionVarName": partitionVarName,+ "ListPartitionNames": listPartitionNames,+ "BoxedBoolIfSet": boxedBoolIfSet,+ "StringIfSet": stringIfSet,+ "StringSliceIfSet": stringSliceIfSet,+ "EndpointIsSet": endpointIsSet,+ "ServicesSet": serviceSet,+}++const v3Tmpl = `+{{ define "defaults" -}}+// Code generated by aws/endpoints/v3model_codegen.go. DO NOT EDIT.++package endpoints++import (+ "regexp"+)++ {{ template "partition consts" $.Resolver }}++ {{ range $_, $partition := $.Resolver }}+ {{ template "partition region consts" $partition }}+ {{ end }}++ {{ if not $.DisableGenerateServiceIDs -}}+ {{ template "service consts" $.Resolver }}+ {{- end }}++ {{ template "endpoint resolvers" $.Resolver }}+{{- end }}++{{ define "partition consts" }}+ // Partition identifiers+ const (+ {{ range $_, $p := . -}}+ {{ ToSymbol $p.ID }}PartitionID = {{ QuoteString $p.ID }} // {{ $p.Name }} partition.+ {{ end -}}+ )+{{- end }}++{{ define "partition region consts" }}+ // {{ .Name }} partition's regions.+ const (+ {{ range $id, $region := .Regions -}}+ {{ ToSymbol $id }}RegionID = {{ QuoteString $id }} // {{ $region.Description }}.+ {{ end -}}+ )+{{- end }}++{{ define "service consts" }}+ // Service identifiers+ const (+ {{ $serviceSet := ServicesSet . -}}+ {{ range $id, $_ := $serviceSet -}}+ {{ ToSymbol $id }}ServiceID = {{ QuoteString $id }} // {{ ToSymbol $id }}.+ {{ end -}}+ )+{{- end }}++{{ define "endpoint resolvers" }}+ // DefaultResolver returns an Endpoint resolver that will be able+ // to resolve endpoints for: {{ ListPartitionNames . }}.+ //+ // Use DefaultPartitions() to get the list of the default partitions.+ func DefaultResolver() Resolver {+ return defaultPartitions+ }++ // DefaultPartitions returns a list of the partitions the SDK is bundled+ // with. The available partitions are: {{ ListPartitionNames . }}.+ //+ // partitions := endpoints.DefaultPartitions+ // for _, p := range partitions {+ // // ... inspect partitions+ // }+ func DefaultPartitions() []Partition {+ return defaultPartitions.Partitions()+ }++ var defaultPartitions = partitions{+ {{ range $_, $partition := . -}}+ {{ PartitionVarName $partition.ID }},+ {{ end }}+ }++ {{ range $_, $partition := . -}}+ {{ $name := PartitionGetter $partition.ID -}}+ // {{ $name }} returns the Resolver for {{ $partition.Name }}.+ func {{ $name }}() Partition {+ return {{ PartitionVarName $partition.ID }}.Partition()+ }+ var {{ PartitionVarName $partition.ID }} = {{ template "gocode Partition" $partition }}+ {{ end }}+{{ end }}++{{ define "default partitions" }}+ func DefaultPartitions() []Partition {+ return []partition{+ {{ range $_, $partition := . -}}+ // {{ ToSymbol $partition.ID}}Partition(),+ {{ end }}+ }+ }+{{ end }}++{{ define "gocode Partition" -}}+partition{+ {{ StringIfSet "ID: %q,\n" .ID -}}+ {{ StringIfSet "Name: %q,\n" .Name -}}+ {{ StringIfSet "DNSSuffix: %q,\n" .DNSSuffix -}}+ RegionRegex: {{ template "gocode RegionRegex" .RegionRegex }},+ {{ if EndpointIsSet .Defaults -}}+ Defaults: {{ template "gocode Endpoint" .Defaults }},+ {{- end }}+ Regions: {{ template "gocode Regions" .Regions }},+ Services: {{ template "gocode Services" .Services }},+}+{{- end }}++{{ define "gocode RegionRegex" -}}+regionRegex{+ Regexp: func() *regexp.Regexp{+ reg, _ := regexp.Compile({{ QuoteString .Regexp.String }})+ return reg+ }(),+}+{{- end }}++{{ define "gocode Regions" -}}+regions{+ {{ range $id, $region := . -}}+ "{{ $id }}": {{ template "gocode Region" $region }},+ {{ end -}}+}+{{- end }}++{{ define "gocode Region" -}}+region{+ {{ StringIfSet "Description: %q,\n" .Description -}}+}+{{- end }}++{{ define "gocode Services" -}}+services{+ {{ range $id, $service := . -}}+ "{{ $id }}": {{ template "gocode Service" $service }},+ {{ end }}+}+{{- end }}++{{ define "gocode Service" -}}+service{+ {{ StringIfSet "PartitionEndpoint: %q,\n" .PartitionEndpoint -}}+ {{ BoxedBoolIfSet "IsRegionalized: %s,\n" .IsRegionalized -}}+ {{ if EndpointIsSet .Defaults -}}+ Defaults: {{ template "gocode Endpoint" .Defaults -}},+ {{- end }}+ {{ if .Endpoints -}}+ Endpoints: {{ template "gocode Endpoints" .Endpoints }},+ {{- end }}+}+{{- end }}++{{ define "gocode Endpoints" -}}+endpoints{+ {{ range $id, $endpoint := . -}}+ "{{ $id }}": {{ template "gocode Endpoint" $endpoint }},+ {{ end }}+}+{{- end }}++{{ define "gocode Endpoint" -}}+endpoint{+ {{ StringIfSet "Hostname: %q,\n" .Hostname -}}+ {{ StringIfSet "SSLCommonName: %q,\n" .SSLCommonName -}}+ {{ StringSliceIfSet "Protocols: []string{%s},\n" .Protocols -}}+ {{ StringSliceIfSet "SignatureVersions: []string{%s},\n" .SignatureVersions -}}+ {{ if or .CredentialScope.Region .CredentialScope.Service -}}+ CredentialScope: credentialScope{+ {{ StringIfSet "Region: %q,\n" .CredentialScope.Region -}}+ {{ StringIfSet "Service: %q,\n" .CredentialScope.Service -}}+ },+ {{- end }}+ {{ BoxedBoolIfSet "HasDualStack: %s,\n" .HasDualStack -}}+ {{ StringIfSet "DualStackHostname: %q,\n" .DualStackHostname -}}++}+{{- end }}+`diff --git a/vendor/github.com/aws/aws-sdk-go/aws/errors.go b/vendor/github.com/aws/aws-sdk-go/aws/errors.gonew file mode 100644index 000000000..fa06f7a8f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/errors.go@@ -0,0 +1,13 @@+package aws++import "github.com/aws/aws-sdk-go/aws/awserr"++var (+ // ErrMissingRegion is an error that is returned if region configuration is+ // not found.+ ErrMissingRegion = awserr.New("MissingRegion", "could not find region configuration", nil)++ // ErrMissingEndpoint is an error that is returned if an endpoint cannot be+ // resolved for a service.+ ErrMissingEndpoint = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil)+)diff --git a/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go b/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.gonew file mode 100644index 000000000..91a6f277a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go@@ -0,0 +1,12 @@+package aws++// JSONValue is a representation of a grab bag type that will be marshaled+// into a json string. This type can be used just like any other map.+//+// Example:+//+// values := aws.JSONValue{+// "Foo": "Bar",+// }+// values["Baz"] = "Qux"+type JSONValue map[string]interface{}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/logger.go b/vendor/github.com/aws/aws-sdk-go/aws/logger.gonew file mode 100644index 000000000..6ed15b2ec--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/logger.go@@ -0,0 +1,118 @@+package aws++import (+ "log"+ "os"+)++// A LogLevelType defines the level logging should be performed at. Used to instruct+// the SDK which statements should be logged.+type LogLevelType uint++// LogLevel returns the pointer to a LogLevel. Should be used to workaround+// not being able to take the address of a non-composite literal.+func LogLevel(l LogLevelType) *LogLevelType {+ return &l+}++// Value returns the LogLevel value or the default value LogOff if the LogLevel+// is nil. Safe to use on nil value LogLevelTypes.+func (l *LogLevelType) Value() LogLevelType {+ if l != nil {+ return *l+ }+ return LogOff+}++// Matches returns true if the v LogLevel is enabled by this LogLevel. Should be+// used with logging sub levels. Is safe to use on nil value LogLevelTypes. If+// LogLevel is nil, will default to LogOff comparison.+func (l *LogLevelType) Matches(v LogLevelType) bool {+ c := l.Value()+ return c&v == v+}++// AtLeast returns true if this LogLevel is at least high enough to satisfies v.+// Is safe to use on nil value LogLevelTypes. If LogLevel is nil, will default+// to LogOff comparison.+func (l *LogLevelType) AtLeast(v LogLevelType) bool {+ c := l.Value()+ return c >= v+}++const (+ // LogOff states that no logging should be performed by the SDK. This is the+ // default state of the SDK, and should be use to disable all logging.+ LogOff LogLevelType = iota * 0x1000++ // LogDebug state that debug output should be logged by the SDK. This should+ // be used to inspect request made and responses received.+ LogDebug+)++// Debug Logging Sub Levels+const (+ // LogDebugWithSigning states that the SDK should log request signing and+ // presigning events. This should be used to log the signing details of+ // requests for debugging. Will also enable LogDebug.+ LogDebugWithSigning LogLevelType = LogDebug | (1 << iota)++ // LogDebugWithHTTPBody states the SDK should log HTTP request and response+ // HTTP bodys in addition to the headers and path. This should be used to+ // see the body content of requests and responses made while using the SDK+ // Will also enable LogDebug.+ LogDebugWithHTTPBody++ // LogDebugWithRequestRetries states the SDK should log when service requests will+ // be retried. This should be used to log when you want to log when service+ // requests are being retried. Will also enable LogDebug.+ LogDebugWithRequestRetries++ // LogDebugWithRequestErrors states the SDK should log when service requests fail+ // to build, send, validate, or unmarshal.+ LogDebugWithRequestErrors++ // LogDebugWithEventStreamBody states the SDK should log EventStream+ // request and response bodys. This should be used to log the EventStream+ // wire unmarshaled message content of requests and responses made while+ // using the SDK Will also enable LogDebug.+ LogDebugWithEventStreamBody+)++// A Logger is a minimalistic interface for the SDK to log messages to. Should+// be used to provide custom logging writers for the SDK to use.+type Logger interface {+ Log(...interface{})+}++// A LoggerFunc is a convenience type to convert a function taking a variadic+// list of arguments and wrap it so the Logger interface can be used.+//+// Example:+// s3.New(sess, &aws.Config{Logger: aws.LoggerFunc(func(args ...interface{}) {+// fmt.Fprintln(os.Stdout, args...)+// })})+type LoggerFunc func(...interface{})++// Log calls the wrapped function with the arguments provided+func (f LoggerFunc) Log(args ...interface{}) {+ f(args...)+}++// NewDefaultLogger returns a Logger which will write log messages to stdout, and+// use same formatting runes as the stdlib log.Logger+func NewDefaultLogger() Logger {+ return &defaultLogger{+ logger: log.New(os.Stdout, "", log.LstdFlags),+ }+}++// A defaultLogger provides a minimalistic logger satisfying the Logger interface.+type defaultLogger struct {+ logger *log.Logger+}++// Log logs the parameters to the stdlib logger. See log.Println.+func (l defaultLogger) Log(args ...interface{}) {+ l.logger.Println(args...)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.gonew file mode 100644index 000000000..271da432c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go@@ -0,0 +1,19 @@+// +build !appengine,!plan9++package request++import (+ "net"+ "os"+ "syscall"+)++func isErrConnectionReset(err error) bool {+ if opErr, ok := err.(*net.OpError); ok {+ if sysErr, ok := opErr.Err.(*os.SyscallError); ok {+ return sysErr.Err == syscall.ECONNRESET+ }+ }++ return false+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_other.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_other.gonew file mode 100644index 000000000..daf9eca43--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_other.go@@ -0,0 +1,11 @@+// +build appengine plan9++package request++import (+ "strings"+)++func isErrConnectionReset(err error) bool {+ return strings.Contains(err.Error(), "connection reset")+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.gonew file mode 100644index 000000000..8ef8548a9--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go@@ -0,0 +1,277 @@+package request++import (+ "fmt"+ "strings"+)++// A Handlers provides a collection of request handlers for various+// stages of handling requests.+type Handlers struct {+ Validate HandlerList+ Build HandlerList+ Sign HandlerList+ Send HandlerList+ ValidateResponse HandlerList+ Unmarshal HandlerList+ UnmarshalStream HandlerList+ UnmarshalMeta HandlerList+ UnmarshalError HandlerList+ Retry HandlerList+ AfterRetry HandlerList+ CompleteAttempt HandlerList+ Complete HandlerList+}++// Copy returns of this handler's lists.+func (h *Handlers) Copy() Handlers {+ return Handlers{+ Validate: h.Validate.copy(),+ Build: h.Build.copy(),+ Sign: h.Sign.copy(),+ Send: h.Send.copy(),+ ValidateResponse: h.ValidateResponse.copy(),+ Unmarshal: h.Unmarshal.copy(),+ UnmarshalStream: h.UnmarshalStream.copy(),+ UnmarshalError: h.UnmarshalError.copy(),+ UnmarshalMeta: h.UnmarshalMeta.copy(),+ Retry: h.Retry.copy(),+ AfterRetry: h.AfterRetry.copy(),+ CompleteAttempt: h.CompleteAttempt.copy(),+ Complete: h.Complete.copy(),+ }+}++// Clear removes callback functions for all handlers+func (h *Handlers) Clear() {+ h.Validate.Clear()+ h.Build.Clear()+ h.Send.Clear()+ h.Sign.Clear()+ h.Unmarshal.Clear()+ h.UnmarshalStream.Clear()+ h.UnmarshalMeta.Clear()+ h.UnmarshalError.Clear()+ h.ValidateResponse.Clear()+ h.Retry.Clear()+ h.AfterRetry.Clear()+ h.CompleteAttempt.Clear()+ h.Complete.Clear()+}++// A HandlerListRunItem represents an entry in the HandlerList which+// is being run.+type HandlerListRunItem struct {+ Index int+ Handler NamedHandler+ Request *Request+}++// A HandlerList manages zero or more handlers in a list.+type HandlerList struct {+ list []NamedHandler++ // Called after each request handler in the list is called. If set+ // and the func returns true the HandlerList will continue to iterate+ // over the request handlers. If false is returned the HandlerList+ // will stop iterating.+ //+ // Should be used if extra logic to be performed between each handler+ // in the list. This can be used to terminate a list's iteration+ // based on a condition such as error like, HandlerListStopOnError.+ // Or for logging like HandlerListLogItem.+ AfterEachFn func(item HandlerListRunItem) bool+}++// A NamedHandler is a struct that contains a name and function callback.+type NamedHandler struct {+ Name string+ Fn func(*Request)+}++// copy creates a copy of the handler list.+func (l *HandlerList) copy() HandlerList {+ n := HandlerList{+ AfterEachFn: l.AfterEachFn,+ }+ if len(l.list) == 0 {+ return n+ }++ n.list = append(make([]NamedHandler, 0, len(l.list)), l.list...)+ return n+}++// Clear clears the handler list.+func (l *HandlerList) Clear() {+ l.list = l.list[0:0]+}++// Len returns the number of handlers in the list.+func (l *HandlerList) Len() int {+ return len(l.list)+}++// PushBack pushes handler f to the back of the handler list.+func (l *HandlerList) PushBack(f func(*Request)) {+ l.PushBackNamed(NamedHandler{"__anonymous", f})+}++// PushBackNamed pushes named handler f to the back of the handler list.+func (l *HandlerList) PushBackNamed(n NamedHandler) {+ if cap(l.list) == 0 {+ l.list = make([]NamedHandler, 0, 5)+ }+ l.list = append(l.list, n)+}++// PushFront pushes handler f to the front of the handler list.+func (l *HandlerList) PushFront(f func(*Request)) {+ l.PushFrontNamed(NamedHandler{"__anonymous", f})+}++// PushFrontNamed pushes named handler f to the front of the handler list.+func (l *HandlerList) PushFrontNamed(n NamedHandler) {+ if cap(l.list) == len(l.list) {+ // Allocating new list required+ l.list = append([]NamedHandler{n}, l.list...)+ } else {+ // Enough room to prepend into list.+ l.list = append(l.list, NamedHandler{})+ copy(l.list[1:], l.list)+ l.list[0] = n+ }+}++// Remove removes a NamedHandler n+func (l *HandlerList) Remove(n NamedHandler) {+ l.RemoveByName(n.Name)+}++// RemoveByName removes a NamedHandler by name.+func (l *HandlerList) RemoveByName(name string) {+ for i := 0; i < len(l.list); i++ {+ m := l.list[i]+ if m.Name == name {+ // Shift array preventing creating new arrays+ copy(l.list[i:], l.list[i+1:])+ l.list[len(l.list)-1] = NamedHandler{}+ l.list = l.list[:len(l.list)-1]++ // decrement list so next check to length is correct+ i--+ }+ }+}++// SwapNamed will swap out any existing handlers with the same name as the+// passed in NamedHandler returning true if handlers were swapped. False is+// returned otherwise.+func (l *HandlerList) SwapNamed(n NamedHandler) (swapped bool) {+ for i := 0; i < len(l.list); i++ {+ if l.list[i].Name == n.Name {+ l.list[i].Fn = n.Fn+ swapped = true+ }+ }++ return swapped+}++// Swap will swap out all handlers matching the name passed in. The matched+// handlers will be swapped in. True is returned if the handlers were swapped.+func (l *HandlerList) Swap(name string, replace NamedHandler) bool {+ var swapped bool++ for i := 0; i < len(l.list); i++ {+ if l.list[i].Name == name {+ l.list[i] = replace+ swapped = true+ }+ }++ return swapped+}++// SetBackNamed will replace the named handler if it exists in the handler list.+// If the handler does not exist the handler will be added to the end of the list.+func (l *HandlerList) SetBackNamed(n NamedHandler) {+ if !l.SwapNamed(n) {+ l.PushBackNamed(n)+ }+}++// SetFrontNamed will replace the named handler if it exists in the handler list.+// If the handler does not exist the handler will be added to the beginning of+// the list.+func (l *HandlerList) SetFrontNamed(n NamedHandler) {+ if !l.SwapNamed(n) {+ l.PushFrontNamed(n)+ }+}++// Run executes all handlers in the list with a given request object.+func (l *HandlerList) Run(r *Request) {+ for i, h := range l.list {+ h.Fn(r)+ item := HandlerListRunItem{+ Index: i, Handler: h, Request: r,+ }+ if l.AfterEachFn != nil && !l.AfterEachFn(item) {+ return+ }+ }+}++// HandlerListLogItem logs the request handler and the state of the+// request's Error value. Always returns true to continue iterating+// request handlers in a HandlerList.+func HandlerListLogItem(item HandlerListRunItem) bool {+ if item.Request.Config.Logger == nil {+ return true+ }+ item.Request.Config.Logger.Log("DEBUG: RequestHandler",+ item.Index, item.Handler.Name, item.Request.Error)++ return true+}++// HandlerListStopOnError returns false to stop the HandlerList iterating+// over request handlers if Request.Error is not nil. True otherwise+// to continue iterating.+func HandlerListStopOnError(item HandlerListRunItem) bool {+ return item.Request.Error == nil+}++// WithAppendUserAgent will add a string to the user agent prefixed with a+// single white space.+func WithAppendUserAgent(s string) Option {+ return func(r *Request) {+ r.Handlers.Build.PushBack(func(r2 *Request) {+ AddToUserAgent(r, s)+ })+ }+}++// MakeAddToUserAgentHandler will add the name/version pair to the User-Agent request+// header. If the extra parameters are provided they will be added as metadata to the+// name/version pair resulting in the following format.+// "name/version (extra0; extra1; ...)"+// The user agent part will be concatenated with this current request's user agent string.+func MakeAddToUserAgentHandler(name, version string, extra ...string) func(*Request) {+ ua := fmt.Sprintf("%s/%s", name, version)+ if len(extra) > 0 {+ ua += fmt.Sprintf(" (%s)", strings.Join(extra, "; "))+ }+ return func(r *Request) {+ AddToUserAgent(r, ua)+ }+}++// MakeAddToUserAgentFreeFormHandler adds the input to the User-Agent request header.+// The input string will be concatenated with the current request's user agent string.+func MakeAddToUserAgentFreeFormHandler(s string) func(*Request) {+ return func(r *Request) {+ AddToUserAgent(r, s)+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.gonew file mode 100644index 000000000..79f79602b--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go@@ -0,0 +1,24 @@+package request++import (+ "io"+ "net/http"+ "net/url"+)++func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request {+ req := new(http.Request)+ *req = *r+ req.URL = &url.URL{}+ *req.URL = *r.URL+ req.Body = body++ req.Header = http.Header{}+ for k, v := range r.Header {+ for _, vv := range v {+ req.Header.Add(k, vv)+ }+ }++ return req+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.gonew file mode 100644index 000000000..b0c2ef4fe--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go@@ -0,0 +1,60 @@+package request++import (+ "io"+ "sync"++ "github.com/aws/aws-sdk-go/internal/sdkio"+)++// offsetReader is a thread-safe io.ReadCloser to prevent racing+// with retrying requests+type offsetReader struct {+ buf io.ReadSeeker+ lock sync.Mutex+ closed bool+}++func newOffsetReader(buf io.ReadSeeker, offset int64) *offsetReader {+ reader := &offsetReader{}+ buf.Seek(offset, sdkio.SeekStart)++ reader.buf = buf+ return reader+}++// Close will close the instance of the offset reader's access to+// the underlying io.ReadSeeker.+func (o *offsetReader) Close() error {+ o.lock.Lock()+ defer o.lock.Unlock()+ o.closed = true+ return nil+}++// Read is a thread-safe read of the underlying io.ReadSeeker+func (o *offsetReader) Read(p []byte) (int, error) {+ o.lock.Lock()+ defer o.lock.Unlock()++ if o.closed {+ return 0, io.EOF+ }++ return o.buf.Read(p)+}++// Seek is a thread-safe seeking operation.+func (o *offsetReader) Seek(offset int64, whence int) (int64, error) {+ o.lock.Lock()+ defer o.lock.Unlock()++ return o.buf.Seek(offset, whence)+}++// CloseAndCopy will return a new offsetReader with a copy of the old buffer+// and close the old buffer.+func (o *offsetReader) CloseAndCopy(offset int64) *offsetReader {+ o.Close()+ return newOffsetReader(o.buf, offset)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request.gonew file mode 100644index 000000000..7d87df65c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go@@ -0,0 +1,658 @@+package request++import (+ "bytes"+ "fmt"+ "io"+ "net"+ "net/http"+ "net/url"+ "reflect"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/internal/sdkio"+)++const (+ // ErrCodeSerialization is the serialization error code that is received+ // during protocol unmarshaling.+ ErrCodeSerialization = "SerializationError"++ // ErrCodeRead is an error that is returned during HTTP reads.+ ErrCodeRead = "ReadError"++ // ErrCodeResponseTimeout is the connection timeout error that is received+ // during body reads.+ ErrCodeResponseTimeout = "ResponseTimeout"++ // ErrCodeInvalidPresignExpire is returned when the expire time provided to+ // presign is invalid+ ErrCodeInvalidPresignExpire = "InvalidPresignExpireError"++ // CanceledErrorCode is the error code that will be returned by an+ // API request that was canceled. Requests given a aws.Context may+ // return this error when canceled.+ CanceledErrorCode = "RequestCanceled"+)++// A Request is the service request to be made.+type Request struct {+ Config aws.Config+ ClientInfo metadata.ClientInfo+ Handlers Handlers++ Retryer+ AttemptTime time.Time+ Time time.Time+ Operation *Operation+ HTTPRequest *http.Request+ HTTPResponse *http.Response+ Body io.ReadSeeker+ BodyStart int64 // offset from beginning of Body that the request body starts+ Params interface{}+ Error error+ Data interface{}+ RequestID string+ RetryCount int+ Retryable *bool+ RetryDelay time.Duration+ NotHoist bool+ SignedHeaderVals http.Header+ LastSignedAt time.Time+ DisableFollowRedirects bool++ // A value greater than 0 instructs the request to be signed as Presigned URL+ // You should not set this field directly. Instead use Request's+ // Presign or PresignRequest methods.+ ExpireTime time.Duration++ context aws.Context++ built bool++ // Need to persist an intermediate body between the input Body and HTTP+ // request body because the HTTP Client's transport can maintain a reference+ // to the HTTP request's body after the client has returned. This value is+ // safe to use concurrently and wrap the input Body for each HTTP request.+ safeBody *offsetReader+}++// An Operation is the service API operation to be made.+type Operation struct {+ Name string+ HTTPMethod string+ HTTPPath string+ *Paginator++ BeforePresignFn func(r *Request) error+}++// New returns a new Request pointer for the service API+// operation and parameters.+//+// Params is any value of input parameters to be the request payload.+// Data is pointer value to an object which the request's response+// payload will be deserialized to.+func New(cfg aws.Config, clientInfo metadata.ClientInfo, handlers Handlers,+ retryer Retryer, operation *Operation, params interface{}, data interface{}) *Request {++ method := operation.HTTPMethod+ if method == "" {+ method = "POST"+ }++ httpReq, _ := http.NewRequest(method, "", nil)++ var err error+ httpReq.URL, err = url.Parse(clientInfo.Endpoint + operation.HTTPPath)+ if err != nil {+ httpReq.URL = &url.URL{}+ err = awserr.New("InvalidEndpointURL", "invalid endpoint uri", err)+ }++ SanitizeHostForHeader(httpReq)++ r := &Request{+ Config: cfg,+ ClientInfo: clientInfo,+ Handlers: handlers.Copy(),++ Retryer: retryer,+ Time: time.Now(),+ ExpireTime: 0,+ Operation: operation,+ HTTPRequest: httpReq,+ Body: nil,+ Params: params,+ Error: err,+ Data: data,+ }+ r.SetBufferBody([]byte{})++ return r+}++// A Option is a functional option that can augment or modify a request when+// using a WithContext API operation method.+type Option func(*Request)++// WithGetResponseHeader builds a request Option which will retrieve a single+// header value from the HTTP Response. If there are multiple values for the+// header key use WithGetResponseHeaders instead to access the http.Header+// map directly. The passed in val pointer must be non-nil.+//+// This Option can be used multiple times with a single API operation.+//+// var id2, versionID string+// svc.PutObjectWithContext(ctx, params,+// request.WithGetResponseHeader("x-amz-id-2", &id2),+// request.WithGetResponseHeader("x-amz-version-id", &versionID),+// )+func WithGetResponseHeader(key string, val *string) Option {+ return func(r *Request) {+ r.Handlers.Complete.PushBack(func(req *Request) {+ *val = req.HTTPResponse.Header.Get(key)+ })+ }+}++// WithGetResponseHeaders builds a request Option which will retrieve the+// headers from the HTTP response and assign them to the passed in headers+// variable. The passed in headers pointer must be non-nil.+//+// var headers http.Header+// svc.PutObjectWithContext(ctx, params, request.WithGetResponseHeaders(&headers))+func WithGetResponseHeaders(headers *http.Header) Option {+ return func(r *Request) {+ r.Handlers.Complete.PushBack(func(req *Request) {+ *headers = req.HTTPResponse.Header+ })+ }+}++// WithLogLevel is a request option that will set the request to use a specific+// log level when the request is made.+//+// svc.PutObjectWithContext(ctx, params, request.WithLogLevel(aws.LogDebugWithHTTPBody)+func WithLogLevel(l aws.LogLevelType) Option {+ return func(r *Request) {+ r.Config.LogLevel = aws.LogLevel(l)+ }+}++// ApplyOptions will apply each option to the request calling them in the order+// the were provided.+func (r *Request) ApplyOptions(opts ...Option) {+ for _, opt := range opts {+ opt(r)+ }+}++// Context will always returns a non-nil context. If Request does not have a+// context aws.BackgroundContext will be returned.+func (r *Request) Context() aws.Context {+ if r.context != nil {+ return r.context+ }+ return aws.BackgroundContext()+}++// SetContext adds a Context to the current request that can be used to cancel+// a in-flight request. The Context value must not be nil, or this method will+// panic.+//+// Unlike http.Request.WithContext, SetContext does not return a copy of the+// Request. It is not safe to use use a single Request value for multiple+// requests. A new Request should be created for each API operation request.+//+// Go 1.6 and below:+// The http.Request's Cancel field will be set to the Done() value of+// the context. This will overwrite the Cancel field's value.+//+// Go 1.7 and above:+// The http.Request.WithContext will be used to set the context on the underlying+// http.Request. This will create a shallow copy of the http.Request. The SDK+// may create sub contexts in the future for nested requests such as retries.+func (r *Request) SetContext(ctx aws.Context) {+ if ctx == nil {+ panic("context cannot be nil")+ }+ setRequestContext(r, ctx)+}++// WillRetry returns if the request's can be retried.+func (r *Request) WillRetry() bool {+ if !aws.IsReaderSeekable(r.Body) && r.HTTPRequest.Body != NoBody {+ return false+ }+ return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.MaxRetries()+}++// ParamsFilled returns if the request's parameters have been populated+// and the parameters are valid. False is returned if no parameters are+// provided or invalid.+func (r *Request) ParamsFilled() bool {+ return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()+}++// DataFilled returns true if the request's data for response deserialization+// target has been set and is a valid. False is returned if data is not+// set, or is invalid.+func (r *Request) DataFilled() bool {+ return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()+}++// SetBufferBody will set the request's body bytes that will be sent to+// the service API.+func (r *Request) SetBufferBody(buf []byte) {+ r.SetReaderBody(bytes.NewReader(buf))+}++// SetStringBody sets the body of the request to be backed by a string.+func (r *Request) SetStringBody(s string) {+ r.SetReaderBody(strings.NewReader(s))+}++// SetReaderBody will set the request's body reader.+func (r *Request) SetReaderBody(reader io.ReadSeeker) {+ r.Body = reader+ r.BodyStart, _ = reader.Seek(0, sdkio.SeekCurrent) // Get the Bodies current offset.+ r.ResetBody()+}++// Presign returns the request's signed URL. Error will be returned+// if the signing fails. The expire parameter is only used for presigned Amazon+// S3 API requests. All other AWS services will use a fixed expriation+// time of 15 minutes.+//+// It is invalid to create a presigned URL with a expire duration 0 or less. An+// error is returned if expire duration is 0 or less.+func (r *Request) Presign(expire time.Duration) (string, error) {+ r = r.copy()++ // Presign requires all headers be hoisted. There is no way to retrieve+ // the signed headers not hoisted without this. Making the presigned URL+ // useless.+ r.NotHoist = false++ u, _, err := getPresignedURL(r, expire)+ return u, err+}++// PresignRequest behaves just like presign, with the addition of returning a+// set of headers that were signed. The expire parameter is only used for+// presigned Amazon S3 API requests. All other AWS services will use a fixed+// expriation time of 15 minutes.+//+// It is invalid to create a presigned URL with a expire duration 0 or less. An+// error is returned if expire duration is 0 or less.+//+// Returns the URL string for the API operation with signature in the query string,+// and the HTTP headers that were included in the signature. These headers must+// be included in any HTTP request made with the presigned URL.+//+// To prevent hoisting any headers to the query string set NotHoist to true on+// this Request value prior to calling PresignRequest.+func (r *Request) PresignRequest(expire time.Duration) (string, http.Header, error) {+ r = r.copy()+ return getPresignedURL(r, expire)+}++// IsPresigned returns true if the request represents a presigned API url.+func (r *Request) IsPresigned() bool {+ return r.ExpireTime != 0+}++func getPresignedURL(r *Request, expire time.Duration) (string, http.Header, error) {+ if expire <= 0 {+ return "", nil, awserr.New(+ ErrCodeInvalidPresignExpire,+ "presigned URL requires an expire duration greater than 0",+ nil,+ )+ }++ r.ExpireTime = expire++ if r.Operation.BeforePresignFn != nil {+ if err := r.Operation.BeforePresignFn(r); err != nil {+ return "", nil, err+ }+ }++ if err := r.Sign(); err != nil {+ return "", nil, err+ }++ return r.HTTPRequest.URL.String(), r.SignedHeaderVals, nil+}++func debugLogReqError(r *Request, stage string, retrying bool, err error) {+ if !r.Config.LogLevel.Matches(aws.LogDebugWithRequestErrors) {+ return+ }++ retryStr := "not retrying"+ if retrying {+ retryStr = "will retry"+ }++ r.Config.Logger.Log(fmt.Sprintf("DEBUG: %s %s/%s failed, %s, error %v",+ stage, r.ClientInfo.ServiceName, r.Operation.Name, retryStr, err))+}++// Build will build the request's object so it can be signed and sent+// to the service. Build will also validate all the request's parameters.+// Any additional build Handlers set on this request will be run+// in the order they were set.+//+// The request will only be built once. Multiple calls to build will have+// no effect.+//+// If any Validate or Build errors occur the build will stop and the error+// which occurred will be returned.+func (r *Request) Build() error {+ if !r.built {+ r.Handlers.Validate.Run(r)+ if r.Error != nil {+ debugLogReqError(r, "Validate Request", false, r.Error)+ return r.Error+ }+ r.Handlers.Build.Run(r)+ if r.Error != nil {+ debugLogReqError(r, "Build Request", false, r.Error)+ return r.Error+ }+ r.built = true+ }++ return r.Error+}++// Sign will sign the request, returning error if errors are encountered.+//+// Sign will build the request prior to signing. All Sign Handlers will+// be executed in the order they were set.+func (r *Request) Sign() error {+ r.Build()+ if r.Error != nil {+ debugLogReqError(r, "Build Request", false, r.Error)+ return r.Error+ }++ r.Handlers.Sign.Run(r)+ return r.Error+}++func (r *Request) getNextRequestBody() (io.ReadCloser, error) {+ if r.safeBody != nil {+ r.safeBody.Close()+ }++ r.safeBody = newOffsetReader(r.Body, r.BodyStart)++ // Go 1.8 tightened and clarified the rules code needs to use when building+ // requests with the http package. Go 1.8 removed the automatic detection+ // of if the Request.Body was empty, or actually had bytes in it. The SDK+ // always sets the Request.Body even if it is empty and should not actually+ // be sent. This is incorrect.+ //+ // Go 1.8 did add a http.NoBody value that the SDK can use to tell the http+ // client that the request really should be sent without a body. The+ // Request.Body cannot be set to nil, which is preferable, because the+ // field is exported and could introduce nil pointer dereferences for users+ // of the SDK if they used that field.+ //+ // Related golang/go#18257+ l, err := aws.SeekerLen(r.Body)+ if err != nil {+ return nil, awserr.New(ErrCodeSerialization, "failed to compute request body size", err)+ }++ var body io.ReadCloser+ if l == 0 {+ body = NoBody+ } else if l > 0 {+ body = r.safeBody+ } else {+ // Hack to prevent sending bodies for methods where the body+ // should be ignored by the server. Sending bodies on these+ // methods without an associated ContentLength will cause the+ // request to socket timeout because the server does not handle+ // Transfer-Encoding: chunked bodies for these methods.+ //+ // This would only happen if a aws.ReaderSeekerCloser was used with+ // a io.Reader that was not also an io.Seeker, or did not implement+ // Len() method.+ switch r.Operation.HTTPMethod {+ case "GET", "HEAD", "DELETE":+ body = NoBody+ default:+ body = r.safeBody+ }+ }++ return body, nil+}++// GetBody will return an io.ReadSeeker of the Request's underlying+// input body with a concurrency safe wrapper.+func (r *Request) GetBody() io.ReadSeeker {+ return r.safeBody+}++// Send will send the request, returning error if errors are encountered.+//+// Send will sign the request prior to sending. All Send Handlers will+// be executed in the order they were set.+//+// Canceling a request is non-deterministic. If a request has been canceled,+// then the transport will choose, randomly, one of the state channels during+// reads or getting the connection.+//+// readLoop() and getConn(req *Request, cm connectMethod)+// https://github.com/golang/go/blob/master/src/net/http/transport.go+//+// Send will not close the request.Request's body.+func (r *Request) Send() error {+ defer func() {+ // Regardless of success or failure of the request trigger the Complete+ // request handlers.+ r.Handlers.Complete.Run(r)+ }()++ if err := r.Error; err != nil {+ return err+ }++ for {+ r.Error = nil+ r.AttemptTime = time.Now()++ if err := r.Sign(); err != nil {+ debugLogReqError(r, "Sign Request", false, err)+ return err+ }++ if err := r.sendRequest(); err == nil {+ return nil+ } else if !shouldRetryCancel(r) {+ return err+ } else {+ r.Handlers.Retry.Run(r)+ r.Handlers.AfterRetry.Run(r)++ if r.Error != nil || !aws.BoolValue(r.Retryable) {+ return r.Error+ }++ r.prepareRetry()+ continue+ }+ }+}++func (r *Request) prepareRetry() {+ if r.Config.LogLevel.Matches(aws.LogDebugWithRequestRetries) {+ r.Config.Logger.Log(fmt.Sprintf("DEBUG: Retrying Request %s/%s, attempt %d",+ r.ClientInfo.ServiceName, r.Operation.Name, r.RetryCount))+ }++ // The previous http.Request will have a reference to the r.Body+ // and the HTTP Client's Transport may still be reading from+ // the request's body even though the Client's Do returned.+ r.HTTPRequest = copyHTTPRequest(r.HTTPRequest, nil)+ r.ResetBody()++ // Closing response body to ensure that no response body is leaked+ // between retry attempts.+ if r.HTTPResponse != nil && r.HTTPResponse.Body != nil {+ r.HTTPResponse.Body.Close()+ }+}++func (r *Request) sendRequest() (sendErr error) {+ defer r.Handlers.CompleteAttempt.Run(r)++ r.Retryable = nil+ r.Handlers.Send.Run(r)+ if r.Error != nil {+ debugLogReqError(r, "Send Request", r.WillRetry(), r.Error)+ return r.Error+ }++ r.Handlers.UnmarshalMeta.Run(r)+ r.Handlers.ValidateResponse.Run(r)+ if r.Error != nil {+ r.Handlers.UnmarshalError.Run(r)+ debugLogReqError(r, "Validate Response", r.WillRetry(), r.Error)+ return r.Error+ }++ r.Handlers.Unmarshal.Run(r)+ if r.Error != nil {+ debugLogReqError(r, "Unmarshal Response", r.WillRetry(), r.Error)+ return r.Error+ }++ return nil+}++// copy will copy a request which will allow for local manipulation of the+// request.+func (r *Request) copy() *Request {+ req := &Request{}+ *req = *r+ req.Handlers = r.Handlers.Copy()+ op := *r.Operation+ req.Operation = &op+ return req+}++// AddToUserAgent adds the string to the end of the request's current user agent.+func AddToUserAgent(r *Request, s string) {+ curUA := r.HTTPRequest.Header.Get("User-Agent")+ if len(curUA) > 0 {+ s = curUA + " " + s+ }+ r.HTTPRequest.Header.Set("User-Agent", s)+}++func shouldRetryCancel(r *Request) bool {+ awsErr, ok := r.Error.(awserr.Error)+ timeoutErr := false+ errStr := r.Error.Error()+ if ok {+ if awsErr.Code() == CanceledErrorCode {+ return false+ }+ err := awsErr.OrigErr()+ netErr, netOK := err.(net.Error)+ timeoutErr = netOK && netErr.Temporary()+ if urlErr, ok := err.(*url.Error); !timeoutErr && ok {+ errStr = urlErr.Err.Error()+ }+ }++ // There can be two types of canceled errors here.+ // The first being a net.Error and the other being an error.+ // If the request was timed out, we want to continue the retry+ // process. Otherwise, return the canceled error.+ return timeoutErr ||+ (errStr != "net/http: request canceled" &&+ errStr != "net/http: request canceled while waiting for connection")++}++// SanitizeHostForHeader removes default port from host and updates request.Host+func SanitizeHostForHeader(r *http.Request) {+ host := getHost(r)+ port := portOnly(host)+ if port != "" && isDefaultPort(r.URL.Scheme, port) {+ r.Host = stripPort(host)+ }+}++// Returns host from request+func getHost(r *http.Request) string {+ if r.Host != "" {+ return r.Host+ }++ return r.URL.Host+}++// Hostname returns u.Host, without any port number.+//+// If Host is an IPv6 literal with a port number, Hostname returns the+// IPv6 literal without the square brackets. IPv6 literals may include+// a zone identifier.+//+// Copied from the Go 1.8 standard library (net/url)+func stripPort(hostport string) string {+ colon := strings.IndexByte(hostport, ':')+ if colon == -1 {+ return hostport+ }+ if i := strings.IndexByte(hostport, ']'); i != -1 {+ return strings.TrimPrefix(hostport[:i], "[")+ }+ return hostport[:colon]+}++// Port returns the port part of u.Host, without the leading colon.+// If u.Host doesn't contain a port, Port returns an empty string.+//+// Copied from the Go 1.8 standard library (net/url)+func portOnly(hostport string) string {+ colon := strings.IndexByte(hostport, ':')+ if colon == -1 {+ return ""+ }+ if i := strings.Index(hostport, "]:"); i != -1 {+ return hostport[i+len("]:"):]+ }+ if strings.Contains(hostport, "]") {+ return ""+ }+ return hostport[colon+len(":"):]+}++// Returns true if the specified URI is using the standard port+// (i.e. port 80 for HTTP URIs or 443 for HTTPS URIs)+func isDefaultPort(scheme, port string) bool {+ if port == "" {+ return true+ }++ lowerCaseScheme := strings.ToLower(scheme)+ if (lowerCaseScheme == "http" && port == "80") || (lowerCaseScheme == "https" && port == "443") {+ return true+ }++ return false+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.gonew file mode 100644index 000000000..e36e468b7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go@@ -0,0 +1,39 @@+// +build !go1.8++package request++import "io"++// NoBody is an io.ReadCloser with no bytes. Read always returns EOF+// and Close always returns nil. It can be used in an outgoing client+// request to explicitly signal that a request has zero bytes.+// An alternative, however, is to simply set Request.Body to nil.+//+// Copy of Go 1.8 NoBody type from net/http/http.go+type noBody struct{}++func (noBody) Read([]byte) (int, error) { return 0, io.EOF }+func (noBody) Close() error { return nil }+func (noBody) WriteTo(io.Writer) (int64, error) { return 0, nil }++// NoBody is an empty reader that will trigger the Go HTTP client to not include+// and body in the HTTP request.+var NoBody = noBody{}++// ResetBody rewinds the request body back to its starting position, and+// sets the HTTP Request body reference. When the body is read prior+// to being sent in the HTTP request it will need to be rewound.+//+// ResetBody will automatically be called by the SDK's build handler, but if+// the request is being used directly ResetBody must be called before the request+// is Sent. SetStringBody, SetBufferBody, and SetReaderBody will automatically+// call ResetBody.+func (r *Request) ResetBody() {+ body, err := r.getNextRequestBody()+ if err != nil {+ r.Error = err+ return+ }++ r.HTTPRequest.Body = body+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.gonew file mode 100644index 000000000..7c6a8000f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go@@ -0,0 +1,33 @@+// +build go1.8++package request++import (+ "net/http"+)++// NoBody is a http.NoBody reader instructing Go HTTP client to not include+// and body in the HTTP request.+var NoBody = http.NoBody++// ResetBody rewinds the request body back to its starting position, and+// sets the HTTP Request body reference. When the body is read prior+// to being sent in the HTTP request it will need to be rewound.+//+// ResetBody will automatically be called by the SDK's build handler, but if+// the request is being used directly ResetBody must be called before the request+// is Sent. SetStringBody, SetBufferBody, and SetReaderBody will automatically+// call ResetBody.+//+// Will also set the Go 1.8's http.Request.GetBody member to allow retrying+// PUT/POST redirects.+func (r *Request) ResetBody() {+ body, err := r.getNextRequestBody()+ if err != nil {+ r.Error = err+ return+ }++ r.HTTPRequest.Body = body+ r.HTTPRequest.GetBody = r.getNextRequestBody+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.gonew file mode 100644index 000000000..a7365cd1e--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go@@ -0,0 +1,14 @@+// +build go1.7++package request++import "github.com/aws/aws-sdk-go/aws"++// setContext updates the Request to use the passed in context for cancellation.+// Context will also be used for request retry delay.+//+// Creates shallow copy of the http.Request with the WithContext method.+func setRequestContext(r *Request, ctx aws.Context) {+ r.context = ctx+ r.HTTPRequest = r.HTTPRequest.WithContext(ctx)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.gonew file mode 100644index 000000000..307fa0705--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go@@ -0,0 +1,14 @@+// +build !go1.7++package request++import "github.com/aws/aws-sdk-go/aws"++// setContext updates the Request to use the passed in context for cancellation.+// Context will also be used for request retry delay.+//+// Creates shallow copy of the http.Request with the WithContext method.+func setRequestContext(r *Request, ctx aws.Context) {+ r.context = ctx+ r.HTTPRequest.Cancel = ctx.Done()+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.gonew file mode 100644index 000000000..a633ed5ac--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go@@ -0,0 +1,264 @@+package request++import (+ "reflect"+ "sync/atomic"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awsutil"+)++// A Pagination provides paginating of SDK API operations which are paginatable.+// Generally you should not use this type directly, but use the "Pages" API+// operations method to automatically perform pagination for you. Such as,+// "S3.ListObjectsPages", and "S3.ListObjectsPagesWithContext" methods.+//+// Pagination differs from a Paginator type in that pagination is the type that+// does the pagination between API operations, and Paginator defines the+// configuration that will be used per page request.+//+// cont := true+// for p.Next() && cont {+// data := p.Page().(*s3.ListObjectsOutput)+// // process the page's data+// }+// return p.Err()+//+// See service client API operation Pages methods for examples how the SDK will+// use the Pagination type.+type Pagination struct {+ // Function to return a Request value for each pagination request.+ // Any configuration or handlers that need to be applied to the request+ // prior to getting the next page should be done here before the request+ // returned.+ //+ // NewRequest should always be built from the same API operations. It is+ // undefined if different API operations are returned on subsequent calls.+ NewRequest func() (*Request, error)+ // EndPageOnSameToken, when enabled, will allow the paginator to stop on+ // token that are the same as its previous tokens.+ EndPageOnSameToken bool++ started bool+ prevTokens []interface{}+ nextTokens []interface{}++ err error+ curPage interface{}+}++// HasNextPage will return true if Pagination is able to determine that the API+// operation has additional pages. False will be returned if there are no more+// pages remaining.+//+// Will always return true if Next has not been called yet.+func (p *Pagination) HasNextPage() bool {+ if !p.started {+ return true+ }++ hasNextPage := len(p.nextTokens) != 0+ if p.EndPageOnSameToken {+ return hasNextPage && !awsutil.DeepEqual(p.nextTokens, p.prevTokens)+ }+ return hasNextPage+}++// Err returns the error Pagination encountered when retrieving the next page.+func (p *Pagination) Err() error {+ return p.err+}++// Page returns the current page. Page should only be called after a successful+// call to Next. It is undefined what Page will return if Page is called after+// Next returns false.+func (p *Pagination) Page() interface{} {+ return p.curPage+}++// Next will attempt to retrieve the next page for the API operation. When a page+// is retrieved true will be returned. If the page cannot be retrieved, or there+// are no more pages false will be returned.+//+// Use the Page method to retrieve the current page data. The data will need+// to be cast to the API operation's output type.+//+// Use the Err method to determine if an error occurred if Page returns false.+func (p *Pagination) Next() bool {+ if !p.HasNextPage() {+ return false+ }++ req, err := p.NewRequest()+ if err != nil {+ p.err = err+ return false+ }++ if p.started {+ for i, intok := range req.Operation.InputTokens {+ awsutil.SetValueAtPath(req.Params, intok, p.nextTokens[i])+ }+ }+ p.started = true++ err = req.Send()+ if err != nil {+ p.err = err+ return false+ }++ p.prevTokens = p.nextTokens+ p.nextTokens = req.nextPageTokens()+ p.curPage = req.Data++ return true+}++// A Paginator is the configuration data that defines how an API operation+// should be paginated. This type is used by the API service models to define+// the generated pagination config for service APIs.+//+// The Pagination type is what provides iterating between pages of an API. It+// is only used to store the token metadata the SDK should use for performing+// pagination.+type Paginator struct {+ InputTokens []string+ OutputTokens []string+ LimitToken string+ TruncationToken string+}++// nextPageTokens returns the tokens to use when asking for the next page of data.+func (r *Request) nextPageTokens() []interface{} {+ if r.Operation.Paginator == nil {+ return nil+ }+ if r.Operation.TruncationToken != "" {+ tr, _ := awsutil.ValuesAtPath(r.Data, r.Operation.TruncationToken)+ if len(tr) == 0 {+ return nil+ }++ switch v := tr[0].(type) {+ case *bool:+ if !aws.BoolValue(v) {+ return nil+ }+ case bool:+ if v == false {+ return nil+ }+ }+ }++ tokens := []interface{}{}+ tokenAdded := false+ for _, outToken := range r.Operation.OutputTokens {+ vs, _ := awsutil.ValuesAtPath(r.Data, outToken)+ if len(vs) == 0 {+ tokens = append(tokens, nil)+ continue+ }+ v := vs[0]++ switch tv := v.(type) {+ case *string:+ if len(aws.StringValue(tv)) == 0 {+ tokens = append(tokens, nil)+ continue+ }+ case string:+ if len(tv) == 0 {+ tokens = append(tokens, nil)+ continue+ }+ }++ tokenAdded = true+ tokens = append(tokens, v)+ }+ if !tokenAdded {+ return nil+ }++ return tokens+}++// Ensure a deprecated item is only logged once instead of each time its used.+func logDeprecatedf(logger aws.Logger, flag *int32, msg string) {+ if logger == nil {+ return+ }+ if atomic.CompareAndSwapInt32(flag, 0, 1) {+ logger.Log(msg)+ }+}++var (+ logDeprecatedHasNextPage int32+ logDeprecatedNextPage int32+ logDeprecatedEachPage int32+)++// HasNextPage returns true if this request has more pages of data available.+//+// Deprecated Use Pagination type for configurable pagination of API operations+func (r *Request) HasNextPage() bool {+ logDeprecatedf(r.Config.Logger, &logDeprecatedHasNextPage,+ "Request.HasNextPage deprecated. Use Pagination type for configurable pagination of API operations")++ return len(r.nextPageTokens()) > 0+}++// NextPage returns a new Request that can be executed to return the next+// page of result data. Call .Send() on this request to execute it.+//+// Deprecated Use Pagination type for configurable pagination of API operations+func (r *Request) NextPage() *Request {+ logDeprecatedf(r.Config.Logger, &logDeprecatedNextPage,+ "Request.NextPage deprecated. Use Pagination type for configurable pagination of API operations")++ tokens := r.nextPageTokens()+ if len(tokens) == 0 {+ return nil+ }++ data := reflect.New(reflect.TypeOf(r.Data).Elem()).Interface()+ nr := New(r.Config, r.ClientInfo, r.Handlers, r.Retryer, r.Operation, awsutil.CopyOf(r.Params), data)+ for i, intok := range nr.Operation.InputTokens {+ awsutil.SetValueAtPath(nr.Params, intok, tokens[i])+ }+ return nr+}++// EachPage iterates over each page of a paginated request object. The fn+// parameter should be a function with the following sample signature:+//+// func(page *T, lastPage bool) bool {+// return true // return false to stop iterating+// }+//+// Where "T" is the structure type matching the output structure of the given+// operation. For example, a request object generated by+// DynamoDB.ListTablesRequest() would expect to see dynamodb.ListTablesOutput+// as the structure "T". The lastPage value represents whether the page is+// the last page of data or not. The return value of this function should+// return true to keep iterating or false to stop.+//+// Deprecated Use Pagination type for configurable pagination of API operations+func (r *Request) EachPage(fn func(data interface{}, isLastPage bool) (shouldContinue bool)) error {+ logDeprecatedf(r.Config.Logger, &logDeprecatedEachPage,+ "Request.EachPage deprecated. Use Pagination type for configurable pagination of API operations")++ for page := r; page != nil; page = page.NextPage() {+ if err := page.Send(); err != nil {+ return err+ }+ if getNextPage := fn(page.Data, !page.HasNextPage()); !getNextPage {+ return page.Error+ }+ }++ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.gonew file mode 100644index 000000000..7bc5da782--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go@@ -0,0 +1,162 @@+package request++import (+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+)++// Retryer is an interface to control retry logic for a given service.+// The default implementation used by most services is the client.DefaultRetryer+// structure, which contains basic retry logic using exponential backoff.+type Retryer interface {+ RetryRules(*Request) time.Duration+ ShouldRetry(*Request) bool+ MaxRetries() int+}++// WithRetryer sets a config Retryer value to the given Config returning it+// for chaining.+func WithRetryer(cfg *aws.Config, retryer Retryer) *aws.Config {+ cfg.Retryer = retryer+ return cfg+}++// retryableCodes is a collection of service response codes which are retry-able+// without any further action.+var retryableCodes = map[string]struct{}{+ "RequestError": {},+ "RequestTimeout": {},+ ErrCodeResponseTimeout: {},+ "RequestTimeoutException": {}, // Glacier's flavor of RequestTimeout+}++var throttleCodes = map[string]struct{}{+ "ProvisionedThroughputExceededException": {},+ "Throttling": {},+ "ThrottlingException": {},+ "RequestLimitExceeded": {},+ "RequestThrottled": {},+ "TooManyRequestsException": {}, // Lambda functions+ "PriorRequestNotComplete": {}, // Route53+ "TransactionInProgressException": {},+}++// credsExpiredCodes is a collection of error codes which signify the credentials+// need to be refreshed. Expired tokens require refreshing of credentials, and+// resigning before the request can be retried.+var credsExpiredCodes = map[string]struct{}{+ "ExpiredToken": {},+ "ExpiredTokenException": {},+ "RequestExpired": {}, // EC2 Only+}++func isCodeThrottle(code string) bool {+ _, ok := throttleCodes[code]+ return ok+}++func isCodeRetryable(code string) bool {+ if _, ok := retryableCodes[code]; ok {+ return true+ }++ return isCodeExpiredCreds(code)+}++func isCodeExpiredCreds(code string) bool {+ _, ok := credsExpiredCodes[code]+ return ok+}++var validParentCodes = map[string]struct{}{+ ErrCodeSerialization: {},+ ErrCodeRead: {},+}++type temporaryError interface {+ Temporary() bool+}++func isNestedErrorRetryable(parentErr awserr.Error) bool {+ if parentErr == nil {+ return false+ }++ if _, ok := validParentCodes[parentErr.Code()]; !ok {+ return false+ }++ err := parentErr.OrigErr()+ if err == nil {+ return false+ }++ if aerr, ok := err.(awserr.Error); ok {+ return isCodeRetryable(aerr.Code())+ }++ if t, ok := err.(temporaryError); ok {+ return t.Temporary() || isErrConnectionReset(err)+ }++ return isErrConnectionReset(err)+}++// IsErrorRetryable returns whether the error is retryable, based on its Code.+// Returns false if error is nil.+func IsErrorRetryable(err error) bool {+ if err != nil {+ if aerr, ok := err.(awserr.Error); ok {+ return isCodeRetryable(aerr.Code()) || isNestedErrorRetryable(aerr)+ }+ }+ return false+}++// IsErrorThrottle returns whether the error is to be throttled based on its code.+// Returns false if error is nil.+func IsErrorThrottle(err error) bool {+ if err != nil {+ if aerr, ok := err.(awserr.Error); ok {+ return isCodeThrottle(aerr.Code())+ }+ }+ return false+}++// IsErrorExpiredCreds returns whether the error code is a credential expiry error.+// Returns false if error is nil.+func IsErrorExpiredCreds(err error) bool {+ if err != nil {+ if aerr, ok := err.(awserr.Error); ok {+ return isCodeExpiredCreds(aerr.Code())+ }+ }+ return false+}++// IsErrorRetryable returns whether the error is retryable, based on its Code.+// Returns false if the request has no Error set.+//+// Alias for the utility function IsErrorRetryable+func (r *Request) IsErrorRetryable() bool {+ return IsErrorRetryable(r.Error)+}++// IsErrorThrottle returns whether the error is to be throttled based on its code.+// Returns false if the request has no Error set+//+// Alias for the utility function IsErrorThrottle+func (r *Request) IsErrorThrottle() bool {+ return IsErrorThrottle(r.Error)+}++// IsErrorExpired returns whether the error code is a credential expiry error.+// Returns false if the request has no Error set.+//+// Alias for the utility function IsErrorExpiredCreds+func (r *Request) IsErrorExpired() bool {+ return IsErrorExpiredCreds(r.Error)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.gonew file mode 100644index 000000000..09a44eb98--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go@@ -0,0 +1,94 @@+package request++import (+ "io"+ "time"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++var timeoutErr = awserr.New(+ ErrCodeResponseTimeout,+ "read on body has reached the timeout limit",+ nil,+)++type readResult struct {+ n int+ err error+}++// timeoutReadCloser will handle body reads that take too long.+// We will return a ErrReadTimeout error if a timeout occurs.+type timeoutReadCloser struct {+ reader io.ReadCloser+ duration time.Duration+}++// Read will spin off a goroutine to call the reader's Read method. We will+// select on the timer's channel or the read's channel. Whoever completes first+// will be returned.+func (r *timeoutReadCloser) Read(b []byte) (int, error) {+ timer := time.NewTimer(r.duration)+ c := make(chan readResult, 1)++ go func() {+ n, err := r.reader.Read(b)+ timer.Stop()+ c <- readResult{n: n, err: err}+ }()++ select {+ case data := <-c:+ return data.n, data.err+ case <-timer.C:+ return 0, timeoutErr+ }+}++func (r *timeoutReadCloser) Close() error {+ return r.reader.Close()+}++const (+ // HandlerResponseTimeout is what we use to signify the name of the+ // response timeout handler.+ HandlerResponseTimeout = "ResponseTimeoutHandler"+)++// adaptToResponseTimeoutError is a handler that will replace any top level error+// to a ErrCodeResponseTimeout, if its child is that.+func adaptToResponseTimeoutError(req *Request) {+ if err, ok := req.Error.(awserr.Error); ok {+ aerr, ok := err.OrigErr().(awserr.Error)+ if ok && aerr.Code() == ErrCodeResponseTimeout {+ req.Error = aerr+ }+ }+}++// WithResponseReadTimeout is a request option that will wrap the body in a timeout read closer.+// This will allow for per read timeouts. If a timeout occurred, we will return the+// ErrCodeResponseTimeout.+//+// svc.PutObjectWithContext(ctx, params, request.WithTimeoutReadCloser(30 * time.Second)+func WithResponseReadTimeout(duration time.Duration) Option {+ return func(r *Request) {++ var timeoutHandler = NamedHandler{+ HandlerResponseTimeout,+ func(req *Request) {+ req.HTTPResponse.Body = &timeoutReadCloser{+ reader: req.HTTPResponse.Body,+ duration: duration,+ }+ }}++ // remove the handler so we are not stomping over any new durations.+ r.Handlers.Send.RemoveByName(HandlerResponseTimeout)+ r.Handlers.Send.PushBackNamed(timeoutHandler)++ r.Handlers.Unmarshal.PushBack(adaptToResponseTimeoutError)+ r.Handlers.UnmarshalError.PushBack(adaptToResponseTimeoutError)+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.gonew file mode 100644index 000000000..8630683f3--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go@@ -0,0 +1,286 @@+package request++import (+ "bytes"+ "fmt"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++const (+ // InvalidParameterErrCode is the error code for invalid parameters errors+ InvalidParameterErrCode = "InvalidParameter"+ // ParamRequiredErrCode is the error code for required parameter errors+ ParamRequiredErrCode = "ParamRequiredError"+ // ParamMinValueErrCode is the error code for fields with too low of a+ // number value.+ ParamMinValueErrCode = "ParamMinValueError"+ // ParamMinLenErrCode is the error code for fields without enough elements.+ ParamMinLenErrCode = "ParamMinLenError"+ // ParamMaxLenErrCode is the error code for value being too long.+ ParamMaxLenErrCode = "ParamMaxLenError"++ // ParamFormatErrCode is the error code for a field with invalid+ // format or characters.+ ParamFormatErrCode = "ParamFormatInvalidError"+)++// Validator provides a way for types to perform validation logic on their+// input values that external code can use to determine if a type's values+// are valid.+type Validator interface {+ Validate() error+}++// An ErrInvalidParams provides wrapping of invalid parameter errors found when+// validating API operation input parameters.+type ErrInvalidParams struct {+ // Context is the base context of the invalid parameter group.+ Context string+ errs []ErrInvalidParam+}++// Add adds a new invalid parameter error to the collection of invalid+// parameters. The context of the invalid parameter will be updated to reflect+// this collection.+func (e *ErrInvalidParams) Add(err ErrInvalidParam) {+ err.SetContext(e.Context)+ e.errs = append(e.errs, err)+}++// AddNested adds the invalid parameter errors from another ErrInvalidParams+// value into this collection. The nested errors will have their nested context+// updated and base context to reflect the merging.+//+// Use for nested validations errors.+func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) {+ for _, err := range nested.errs {+ err.SetContext(e.Context)+ err.AddNestedContext(nestedCtx)+ e.errs = append(e.errs, err)+ }+}++// Len returns the number of invalid parameter errors+func (e ErrInvalidParams) Len() int {+ return len(e.errs)+}++// Code returns the code of the error+func (e ErrInvalidParams) Code() string {+ return InvalidParameterErrCode+}++// Message returns the message of the error+func (e ErrInvalidParams) Message() string {+ return fmt.Sprintf("%d validation error(s) found.", len(e.errs))+}++// Error returns the string formatted form of the invalid parameters.+func (e ErrInvalidParams) Error() string {+ w := &bytes.Buffer{}+ fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message())++ for _, err := range e.errs {+ fmt.Fprintf(w, "- %s\n", err.Message())+ }++ return w.String()+}++// OrigErr returns the invalid parameters as a awserr.BatchedErrors value+func (e ErrInvalidParams) OrigErr() error {+ return awserr.NewBatchError(+ InvalidParameterErrCode, e.Message(), e.OrigErrs())+}++// OrigErrs returns a slice of the invalid parameters+func (e ErrInvalidParams) OrigErrs() []error {+ errs := make([]error, len(e.errs))+ for i := 0; i < len(errs); i++ {+ errs[i] = e.errs[i]+ }++ return errs+}++// An ErrInvalidParam represents an invalid parameter error type.+type ErrInvalidParam interface {+ awserr.Error++ // Field name the error occurred on.+ Field() string++ // SetContext updates the context of the error.+ SetContext(string)++ // AddNestedContext updates the error's context to include a nested level.+ AddNestedContext(string)+}++type errInvalidParam struct {+ context string+ nestedContext string+ field string+ code string+ msg string+}++// Code returns the error code for the type of invalid parameter.+func (e *errInvalidParam) Code() string {+ return e.code+}++// Message returns the reason the parameter was invalid, and its context.+func (e *errInvalidParam) Message() string {+ return fmt.Sprintf("%s, %s.", e.msg, e.Field())+}++// Error returns the string version of the invalid parameter error.+func (e *errInvalidParam) Error() string {+ return fmt.Sprintf("%s: %s", e.code, e.Message())+}++// OrigErr returns nil, Implemented for awserr.Error interface.+func (e *errInvalidParam) OrigErr() error {+ return nil+}++// Field Returns the field and context the error occurred.+func (e *errInvalidParam) Field() string {+ field := e.context+ if len(field) > 0 {+ field += "."+ }+ if len(e.nestedContext) > 0 {+ field += fmt.Sprintf("%s.", e.nestedContext)+ }+ field += e.field++ return field+}++// SetContext updates the base context of the error.+func (e *errInvalidParam) SetContext(ctx string) {+ e.context = ctx+}++// AddNestedContext prepends a context to the field's path.+func (e *errInvalidParam) AddNestedContext(ctx string) {+ if len(e.nestedContext) == 0 {+ e.nestedContext = ctx+ } else {+ e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)+ }++}++// An ErrParamRequired represents an required parameter error.+type ErrParamRequired struct {+ errInvalidParam+}++// NewErrParamRequired creates a new required parameter error.+func NewErrParamRequired(field string) *ErrParamRequired {+ return &ErrParamRequired{+ errInvalidParam{+ code: ParamRequiredErrCode,+ field: field,+ msg: fmt.Sprintf("missing required field"),+ },+ }+}++// An ErrParamMinValue represents a minimum value parameter error.+type ErrParamMinValue struct {+ errInvalidParam+ min float64+}++// NewErrParamMinValue creates a new minimum value parameter error.+func NewErrParamMinValue(field string, min float64) *ErrParamMinValue {+ return &ErrParamMinValue{+ errInvalidParam: errInvalidParam{+ code: ParamMinValueErrCode,+ field: field,+ msg: fmt.Sprintf("minimum field value of %v", min),+ },+ min: min,+ }+}++// MinValue returns the field's require minimum value.+//+// float64 is returned for both int and float min values.+func (e *ErrParamMinValue) MinValue() float64 {+ return e.min+}++// An ErrParamMinLen represents a minimum length parameter error.+type ErrParamMinLen struct {+ errInvalidParam+ min int+}++// NewErrParamMinLen creates a new minimum length parameter error.+func NewErrParamMinLen(field string, min int) *ErrParamMinLen {+ return &ErrParamMinLen{+ errInvalidParam: errInvalidParam{+ code: ParamMinLenErrCode,+ field: field,+ msg: fmt.Sprintf("minimum field size of %v", min),+ },+ min: min,+ }+}++// MinLen returns the field's required minimum length.+func (e *ErrParamMinLen) MinLen() int {+ return e.min+}++// An ErrParamMaxLen represents a maximum length parameter error.+type ErrParamMaxLen struct {+ errInvalidParam+ max int+}++// NewErrParamMaxLen creates a new maximum length parameter error.+func NewErrParamMaxLen(field string, max int, value string) *ErrParamMaxLen {+ return &ErrParamMaxLen{+ errInvalidParam: errInvalidParam{+ code: ParamMaxLenErrCode,+ field: field,+ msg: fmt.Sprintf("maximum size of %v, %v", max, value),+ },+ max: max,+ }+}++// MaxLen returns the field's required minimum length.+func (e *ErrParamMaxLen) MaxLen() int {+ return e.max+}++// An ErrParamFormat represents a invalid format parameter error.+type ErrParamFormat struct {+ errInvalidParam+ format string+}++// NewErrParamFormat creates a new invalid format parameter error.+func NewErrParamFormat(field string, format, value string) *ErrParamFormat {+ return &ErrParamFormat{+ errInvalidParam: errInvalidParam{+ code: ParamFormatErrCode,+ field: field,+ msg: fmt.Sprintf("format %v, %v", format, value),+ },+ format: format,+ }+}++// Format returns the field's required format.+func (e *ErrParamFormat) Format() string {+ return e.format+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.gonew file mode 100644index 000000000..4601f883c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go@@ -0,0 +1,295 @@+package request++import (+ "fmt"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/awsutil"+)++// WaiterResourceNotReadyErrorCode is the error code returned by a waiter when+// the waiter's max attempts have been exhausted.+const WaiterResourceNotReadyErrorCode = "ResourceNotReady"++// A WaiterOption is a function that will update the Waiter value's fields to+// configure the waiter.+type WaiterOption func(*Waiter)++// WithWaiterMaxAttempts returns the maximum number of times the waiter should+// attempt to check the resource for the target state.+func WithWaiterMaxAttempts(max int) WaiterOption {+ return func(w *Waiter) {+ w.MaxAttempts = max+ }+}++// WaiterDelay will return a delay the waiter should pause between attempts to+// check the resource state. The passed in attempt is the number of times the+// Waiter has checked the resource state.+//+// Attempt is the number of attempts the Waiter has made checking the resource+// state.+type WaiterDelay func(attempt int) time.Duration++// ConstantWaiterDelay returns a WaiterDelay that will always return a constant+// delay the waiter should use between attempts. It ignores the number of+// attempts made.+func ConstantWaiterDelay(delay time.Duration) WaiterDelay {+ return func(attempt int) time.Duration {+ return delay+ }+}++// WithWaiterDelay will set the Waiter to use the WaiterDelay passed in.+func WithWaiterDelay(delayer WaiterDelay) WaiterOption {+ return func(w *Waiter) {+ w.Delay = delayer+ }+}++// WithWaiterLogger returns a waiter option to set the logger a waiter+// should use to log warnings and errors to.+func WithWaiterLogger(logger aws.Logger) WaiterOption {+ return func(w *Waiter) {+ w.Logger = logger+ }+}++// WithWaiterRequestOptions returns a waiter option setting the request+// options for each request the waiter makes. Appends to waiter's request+// options already set.+func WithWaiterRequestOptions(opts ...Option) WaiterOption {+ return func(w *Waiter) {+ w.RequestOptions = append(w.RequestOptions, opts...)+ }+}++// A Waiter provides the functionality to perform a blocking call which will+// wait for a resource state to be satisfied by a service.+//+// This type should not be used directly. The API operations provided in the+// service packages prefixed with "WaitUntil" should be used instead.+type Waiter struct {+ Name string+ Acceptors []WaiterAcceptor+ Logger aws.Logger++ MaxAttempts int+ Delay WaiterDelay++ RequestOptions []Option+ NewRequest func([]Option) (*Request, error)+ SleepWithContext func(aws.Context, time.Duration) error+}++// ApplyOptions updates the waiter with the list of waiter options provided.+func (w *Waiter) ApplyOptions(opts ...WaiterOption) {+ for _, fn := range opts {+ fn(w)+ }+}++// WaiterState are states the waiter uses based on WaiterAcceptor definitions+// to identify if the resource state the waiter is waiting on has occurred.+type WaiterState int++// String returns the string representation of the waiter state.+func (s WaiterState) String() string {+ switch s {+ case SuccessWaiterState:+ return "success"+ case FailureWaiterState:+ return "failure"+ case RetryWaiterState:+ return "retry"+ default:+ return "unknown waiter state"+ }+}++// States the waiter acceptors will use to identify target resource states.+const (+ SuccessWaiterState WaiterState = iota // waiter successful+ FailureWaiterState // waiter failed+ RetryWaiterState // waiter needs to be retried+)++// WaiterMatchMode is the mode that the waiter will use to match the WaiterAcceptor+// definition's Expected attribute.+type WaiterMatchMode int++// Modes the waiter will use when inspecting API response to identify target+// resource states.+const (+ PathAllWaiterMatch WaiterMatchMode = iota // match on all paths+ PathWaiterMatch // match on specific path+ PathAnyWaiterMatch // match on any path+ PathListWaiterMatch // match on list of paths+ StatusWaiterMatch // match on status code+ ErrorWaiterMatch // match on error+)++// String returns the string representation of the waiter match mode.+func (m WaiterMatchMode) String() string {+ switch m {+ case PathAllWaiterMatch:+ return "pathAll"+ case PathWaiterMatch:+ return "path"+ case PathAnyWaiterMatch:+ return "pathAny"+ case PathListWaiterMatch:+ return "pathList"+ case StatusWaiterMatch:+ return "status"+ case ErrorWaiterMatch:+ return "error"+ default:+ return "unknown waiter match mode"+ }+}++// WaitWithContext will make requests for the API operation using NewRequest to+// build API requests. The request's response will be compared against the+// Waiter's Acceptors to determine the successful state of the resource the+// waiter is inspecting.+//+// The passed in context must not be nil. If it is nil a panic will occur. The+// Context will be used to cancel the waiter's pending requests and retry delays.+// Use aws.BackgroundContext if no context is available.+//+// The waiter will continue until the target state defined by the Acceptors,+// or the max attempts expires.+//+// Will return the WaiterResourceNotReadyErrorCode error code if the waiter's+// retryer ShouldRetry returns false. This normally will happen when the max+// wait attempts expires.+func (w Waiter) WaitWithContext(ctx aws.Context) error {++ for attempt := 1; ; attempt++ {+ req, err := w.NewRequest(w.RequestOptions)+ if err != nil {+ waiterLogf(w.Logger, "unable to create request %v", err)+ return err+ }+ req.Handlers.Build.PushBack(MakeAddToUserAgentFreeFormHandler("Waiter"))+ err = req.Send()++ // See if any of the acceptors match the request's response, or error+ for _, a := range w.Acceptors {+ if matched, matchErr := a.match(w.Name, w.Logger, req, err); matched {+ return matchErr+ }+ }++ // The Waiter should only check the resource state MaxAttempts times+ // This is here instead of in the for loop above to prevent delaying+ // unnecessary when the waiter will not retry.+ if attempt == w.MaxAttempts {+ break+ }++ // Delay to wait before inspecting the resource again+ delay := w.Delay(attempt)+ if sleepFn := req.Config.SleepDelay; sleepFn != nil {+ // Support SleepDelay for backwards compatibility and testing+ sleepFn(delay)+ } else {+ sleepCtxFn := w.SleepWithContext+ if sleepCtxFn == nil {+ sleepCtxFn = aws.SleepWithContext+ }++ if err := sleepCtxFn(ctx, delay); err != nil {+ return awserr.New(CanceledErrorCode, "waiter context canceled", err)+ }+ }+ }++ return awserr.New(WaiterResourceNotReadyErrorCode, "exceeded wait attempts", nil)+}++// A WaiterAcceptor provides the information needed to wait for an API operation+// to complete.+type WaiterAcceptor struct {+ State WaiterState+ Matcher WaiterMatchMode+ Argument string+ Expected interface{}+}++// match returns if the acceptor found a match with the passed in request+// or error. True is returned if the acceptor made a match, error is returned+// if there was an error attempting to perform the match.+func (a *WaiterAcceptor) match(name string, l aws.Logger, req *Request, err error) (bool, error) {+ result := false+ var vals []interface{}++ switch a.Matcher {+ case PathAllWaiterMatch, PathWaiterMatch:+ // Require all matches to be equal for result to match+ vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)+ if len(vals) == 0 {+ break+ }+ result = true+ for _, val := range vals {+ if !awsutil.DeepEqual(val, a.Expected) {+ result = false+ break+ }+ }+ case PathAnyWaiterMatch:+ // Only a single match needs to equal for the result to match+ vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)+ for _, val := range vals {+ if awsutil.DeepEqual(val, a.Expected) {+ result = true+ break+ }+ }+ case PathListWaiterMatch:+ // ignored matcher+ case StatusWaiterMatch:+ s := a.Expected.(int)+ result = s == req.HTTPResponse.StatusCode+ case ErrorWaiterMatch:+ if aerr, ok := err.(awserr.Error); ok {+ result = aerr.Code() == a.Expected.(string)+ }+ default:+ waiterLogf(l, "WARNING: Waiter %s encountered unexpected matcher: %s",+ name, a.Matcher)+ }++ if !result {+ // If there was no matching result found there is nothing more to do+ // for this response, retry the request.+ return false, nil+ }++ switch a.State {+ case SuccessWaiterState:+ // waiter completed+ return true, nil+ case FailureWaiterState:+ // Waiter failure state triggered+ return true, awserr.New(WaiterResourceNotReadyErrorCode,+ "failed waiting for successful resource state", err)+ case RetryWaiterState:+ // clear the error and retry the operation+ return false, nil+ default:+ waiterLogf(l, "WARNING: Waiter %s encountered unexpected state: %s",+ name, a.State)+ return false, nil+ }+}++func waiterLogf(logger aws.Logger, msg string, args ...interface{}) {+ if logger != nil {+ logger.Log(fmt.Sprintf(msg, args...))+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/doc.go b/vendor/github.com/aws/aws-sdk-go/aws/session/doc.gonew file mode 100644index 000000000..2a0e882d0--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/doc.go@@ -0,0 +1,273 @@+/*+Package session provides configuration for the SDK's service clients.++Sessions can be shared across all service clients that share the same base+configuration. The Session is built from the SDK's default configuration and+request handlers.++Sessions should be cached when possible, because creating a new Session will+load all configuration values from the environment, and config files each time+the Session is created. Sharing the Session value across all of your service+clients will ensure the configuration is loaded the fewest number of times possible.++Concurrency++Sessions are safe to use concurrently as long as the Session is not being+modified. The SDK will not modify the Session once the Session has been created.+Creating service clients concurrently from a shared Session is safe.++Sessions from Shared Config++Sessions can be created using the method above that will only load the+additional config if the AWS_SDK_LOAD_CONFIG environment variable is set.+Alternatively you can explicitly create a Session with shared config enabled.+To do this you can use NewSessionWithOptions to configure how the Session will+be created. Using the NewSessionWithOptions with SharedConfigState set to+SharedConfigEnable will create the session as if the AWS_SDK_LOAD_CONFIG+environment variable was set.++Creating Sessions++When creating Sessions optional aws.Config values can be passed in that will+override the default, or loaded config values the Session is being created+with. This allows you to provide additional, or case based, configuration+as needed.++By default NewSession will only load credentials from the shared credentials+file (~/.aws/credentials). If the AWS_SDK_LOAD_CONFIG environment variable is+set to a truthy value the Session will be created from the configuration+values from the shared config (~/.aws/config) and shared credentials+(~/.aws/credentials) files. See the section Sessions from Shared Config for+more information.++Create a Session with the default config and request handlers. With credentials+region, and profile loaded from the environment and shared config automatically.+Requires the AWS_PROFILE to be set, or "default" is used.++ // Create Session+ sess := session.Must(session.NewSession())++ // Create a Session with a custom region+ sess := session.Must(session.NewSession(&aws.Config{+ Region: aws.String("us-east-1"),+ }))++ // Create a S3 client instance from a session+ sess := session.Must(session.NewSession())++ svc := s3.New(sess)++Create Session With Option Overrides++In addition to NewSession, Sessions can be created using NewSessionWithOptions.+This func allows you to control and override how the Session will be created+through code instead of being driven by environment variables only.++Use NewSessionWithOptions when you want to provide the config profile, or+override the shared config state (AWS_SDK_LOAD_CONFIG).++ // Equivalent to session.NewSession()+ sess := session.Must(session.NewSessionWithOptions(session.Options{+ // Options+ }))++ // Specify profile to load for the session's config+ sess := session.Must(session.NewSessionWithOptions(session.Options{+ Profile: "profile_name",+ }))++ // Specify profile for config and region for requests+ sess := session.Must(session.NewSessionWithOptions(session.Options{+ Config: aws.Config{Region: aws.String("us-east-1")},+ Profile: "profile_name",+ }))++ // Force enable Shared Config support+ sess := session.Must(session.NewSessionWithOptions(session.Options{+ SharedConfigState: session.SharedConfigEnable,+ }))++Adding Handlers++You can add handlers to a session for processing HTTP requests. All service+clients that use the session inherit the handlers. For example, the following+handler logs every request and its payload made by a service client:++ // Create a session, and add additional handlers for all service+ // clients created with the Session to inherit. Adds logging handler.+ sess := session.Must(session.NewSession())++ sess.Handlers.Send.PushFront(func(r *request.Request) {+ // Log every request made and its payload+ logger.Printf("Request: %s/%s, Payload: %s",+ r.ClientInfo.ServiceName, r.Operation, r.Params)+ })++Deprecated "New" function++The New session function has been deprecated because it does not provide good+way to return errors that occur when loading the configuration files and values.+Because of this, NewSession was created so errors can be retrieved when+creating a session fails.++Shared Config Fields++By default the SDK will only load the shared credentials file's (~/.aws/credentials)+credentials values, and all other config is provided by the environment variables,+SDK defaults, and user provided aws.Config values.++If the AWS_SDK_LOAD_CONFIG environment variable is set, or SharedConfigEnable+option is used to create the Session the full shared config values will be+loaded. This includes credentials, region, and support for assume role. In+addition the Session will load its configuration from both the shared config+file (~/.aws/config) and shared credentials file (~/.aws/credentials). Both+files have the same format.++If both config files are present the configuration from both files will be+read. The Session will be created from configuration values from the shared+credentials file (~/.aws/credentials) over those in the shared config file (~/.aws/config).++Credentials are the values the SDK should use for authenticating requests with+AWS Services. They are from a configuration file will need to include both+aws_access_key_id and aws_secret_access_key must be provided together in the+same file to be considered valid. The values will be ignored if not a complete+group. aws_session_token is an optional field that can be provided if both of+the other two fields are also provided.++ aws_access_key_id = AKID+ aws_secret_access_key = SECRET+ aws_session_token = TOKEN++Assume Role values allow you to configure the SDK to assume an IAM role using+a set of credentials provided in a config file via the source_profile field.+Both "role_arn" and "source_profile" are required. The SDK supports assuming+a role with MFA token if the session option AssumeRoleTokenProvider+is set.++ role_arn = arn:aws:iam::<account_number>:role/<role_name>+ source_profile = profile_with_creds+ external_id = 1234+ mfa_serial = <serial or mfa arn>+ role_session_name = session_name++Region is the region the SDK should use for looking up AWS service endpoints+and signing requests.++ region = us-east-1++Assume Role with MFA token++To create a session with support for assuming an IAM role with MFA set the+session option AssumeRoleTokenProvider to a function that will prompt for the+MFA token code when the SDK assumes the role and refreshes the role's credentials.+This allows you to configure the SDK via the shared config to assumea role+with MFA tokens.++In order for the SDK to assume a role with MFA the SharedConfigState+session option must be set to SharedConfigEnable, or AWS_SDK_LOAD_CONFIG+environment variable set.++The shared configuration instructs the SDK to assume an IAM role with MFA+when the mfa_serial configuration field is set in the shared config+(~/.aws/config) or shared credentials (~/.aws/credentials) file.++If mfa_serial is set in the configuration, the SDK will assume the role, and+the AssumeRoleTokenProvider session option is not set an an error will+be returned when creating the session.++ sess := session.Must(session.NewSessionWithOptions(session.Options{+ AssumeRoleTokenProvider: stscreds.StdinTokenProvider,+ }))++ // Create service client value configured for credentials+ // from assumed role.+ svc := s3.New(sess)++To setup assume role outside of a session see the stscrds.AssumeRoleProvider+documentation.++Environment Variables++When a Session is created several environment variables can be set to adjust+how the SDK functions, and what configuration data it loads when creating+Sessions. All environment values are optional, but some values like credentials+require multiple of the values to set or the partial values will be ignored.+All environment variable values are strings unless otherwise noted.++Environment configuration values. If set both Access Key ID and Secret Access+Key must be provided. Session Token and optionally also be provided, but is+not required.++ # Access Key ID+ AWS_ACCESS_KEY_ID=AKID+ AWS_ACCESS_KEY=AKID # only read if AWS_ACCESS_KEY_ID is not set.++ # Secret Access Key+ AWS_SECRET_ACCESS_KEY=SECRET+ AWS_SECRET_KEY=SECRET=SECRET # only read if AWS_SECRET_ACCESS_KEY is not set.++ # Session Token+ AWS_SESSION_TOKEN=TOKEN++Region value will instruct the SDK where to make service API requests to. If is+not provided in the environment the region must be provided before a service+client request is made.++ AWS_REGION=us-east-1++ # AWS_DEFAULT_REGION is only read if AWS_SDK_LOAD_CONFIG is also set,+ # and AWS_REGION is not also set.+ AWS_DEFAULT_REGION=us-east-1++Profile name the SDK should load use when loading shared config from the+configuration files. If not provided "default" will be used as the profile name.++ AWS_PROFILE=my_profile++ # AWS_DEFAULT_PROFILE is only read if AWS_SDK_LOAD_CONFIG is also set,+ # and AWS_PROFILE is not also set.+ AWS_DEFAULT_PROFILE=my_profile++SDK load config instructs the SDK to load the shared config in addition to+shared credentials. This also expands the configuration loaded so the shared+credentials will have parity with the shared config file. This also enables+Region and Profile support for the AWS_DEFAULT_REGION and AWS_DEFAULT_PROFILE+env values as well.++ AWS_SDK_LOAD_CONFIG=1++Shared credentials file path can be set to instruct the SDK to use an alternative+file for the shared credentials. If not set the file will be loaded from+$HOME/.aws/credentials on Linux/Unix based systems, and+%USERPROFILE%\.aws\credentials on Windows.++ AWS_SHARED_CREDENTIALS_FILE=$HOME/my_shared_credentials++Shared config file path can be set to instruct the SDK to use an alternative+file for the shared config. If not set the file will be loaded from+$HOME/.aws/config on Linux/Unix based systems, and+%USERPROFILE%\.aws\config on Windows.++ AWS_CONFIG_FILE=$HOME/my_shared_config++Path to a custom Credentials Authority (CA) bundle PEM file that the SDK+will use instead of the default system's root CA bundle. Use this only+if you want to replace the CA bundle the SDK uses for TLS requests.++ AWS_CA_BUNDLE=$HOME/my_custom_ca_bundle++Enabling this option will attempt to merge the Transport into the SDK's HTTP+client. If the client's Transport is not a http.Transport an error will be+returned. If the Transport's TLS config is set this option will cause the SDK+to overwrite the Transport's TLS config's RootCAs value. If the CA bundle file+contains multiple certificates all of them will be loaded.++The Session option CustomCABundle is also available when creating sessions+to also enable this feature. CustomCABundle session option field has priority+over the AWS_CA_BUNDLE environment variable, and will be used if both are set.++Setting a custom HTTPClient in the aws.Config options will override this setting.+To use this option and custom HTTP client, the HTTP client needs to be provided+when creating the session. Not the service client.+*/+package sessiondiff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.go b/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.gonew file mode 100644index 000000000..c94d0fb9a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/env_config.go@@ -0,0 +1,236 @@+package session++import (+ "os"+ "strconv"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/defaults"+)++// EnvProviderName provides a name of the provider when config is loaded from environment.+const EnvProviderName = "EnvConfigCredentials"++// envConfig is a collection of environment values the SDK will read+// setup config from. All environment values are optional. But some values+// such as credentials require multiple values to be complete or the values+// will be ignored.+type envConfig struct {+ // Environment configuration values. If set both Access Key ID and Secret Access+ // Key must be provided. Session Token and optionally also be provided, but is+ // not required.+ //+ // # Access Key ID+ // AWS_ACCESS_KEY_ID=AKID+ // AWS_ACCESS_KEY=AKID # only read if AWS_ACCESS_KEY_ID is not set.+ //+ // # Secret Access Key+ // AWS_SECRET_ACCESS_KEY=SECRET+ // AWS_SECRET_KEY=SECRET=SECRET # only read if AWS_SECRET_ACCESS_KEY is not set.+ //+ // # Session Token+ // AWS_SESSION_TOKEN=TOKEN+ Creds credentials.Value++ // Region value will instruct the SDK where to make service API requests to. If is+ // not provided in the environment the region must be provided before a service+ // client request is made.+ //+ // AWS_REGION=us-east-1+ //+ // # AWS_DEFAULT_REGION is only read if AWS_SDK_LOAD_CONFIG is also set,+ // # and AWS_REGION is not also set.+ // AWS_DEFAULT_REGION=us-east-1+ Region string++ // Profile name the SDK should load use when loading shared configuration from the+ // shared configuration files. If not provided "default" will be used as the+ // profile name.+ //+ // AWS_PROFILE=my_profile+ //+ // # AWS_DEFAULT_PROFILE is only read if AWS_SDK_LOAD_CONFIG is also set,+ // # and AWS_PROFILE is not also set.+ // AWS_DEFAULT_PROFILE=my_profile+ Profile string++ // SDK load config instructs the SDK to load the shared config in addition to+ // shared credentials. This also expands the configuration loaded from the shared+ // credentials to have parity with the shared config file. This also enables+ // Region and Profile support for the AWS_DEFAULT_REGION and AWS_DEFAULT_PROFILE+ // env values as well.+ //+ // AWS_SDK_LOAD_CONFIG=1+ EnableSharedConfig bool++ // Shared credentials file path can be set to instruct the SDK to use an alternate+ // file for the shared credentials. If not set the file will be loaded from+ // $HOME/.aws/credentials on Linux/Unix based systems, and+ // %USERPROFILE%\.aws\credentials on Windows.+ //+ // AWS_SHARED_CREDENTIALS_FILE=$HOME/my_shared_credentials+ SharedCredentialsFile string++ // Shared config file path can be set to instruct the SDK to use an alternate+ // file for the shared config. If not set the file will be loaded from+ // $HOME/.aws/config on Linux/Unix based systems, and+ // %USERPROFILE%\.aws\config on Windows.+ //+ // AWS_CONFIG_FILE=$HOME/my_shared_config+ SharedConfigFile string++ // Sets the path to a custom Credentials Authroity (CA) Bundle PEM file+ // that the SDK will use instead of the system's root CA bundle.+ // Only use this if you want to configure the SDK to use a custom set+ // of CAs.+ //+ // Enabling this option will attempt to merge the Transport+ // into the SDK's HTTP client. If the client's Transport is+ // not a http.Transport an error will be returned. If the+ // Transport's TLS config is set this option will cause the+ // SDK to overwrite the Transport's TLS config's RootCAs value.+ //+ // Setting a custom HTTPClient in the aws.Config options will override this setting.+ // To use this option and custom HTTP client, the HTTP client needs to be provided+ // when creating the session. Not the service client.+ //+ // AWS_CA_BUNDLE=$HOME/my_custom_ca_bundle+ CustomCABundle string++ csmEnabled string+ CSMEnabled bool+ CSMPort string+ CSMClientID string++ enableEndpointDiscovery string+ // Enables endpoint discovery via environment variables.+ //+ // AWS_ENABLE_ENDPOINT_DISCOVERY=true+ EnableEndpointDiscovery *bool+}++var (+ csmEnabledEnvKey = []string{+ "AWS_CSM_ENABLED",+ }+ csmPortEnvKey = []string{+ "AWS_CSM_PORT",+ }+ csmClientIDEnvKey = []string{+ "AWS_CSM_CLIENT_ID",+ }+ credAccessEnvKey = []string{+ "AWS_ACCESS_KEY_ID",+ "AWS_ACCESS_KEY",+ }+ credSecretEnvKey = []string{+ "AWS_SECRET_ACCESS_KEY",+ "AWS_SECRET_KEY",+ }+ credSessionEnvKey = []string{+ "AWS_SESSION_TOKEN",+ }++ enableEndpointDiscoveryEnvKey = []string{+ "AWS_ENABLE_ENDPOINT_DISCOVERY",+ }++ regionEnvKeys = []string{+ "AWS_REGION",+ "AWS_DEFAULT_REGION", // Only read if AWS_SDK_LOAD_CONFIG is also set+ }+ profileEnvKeys = []string{+ "AWS_PROFILE",+ "AWS_DEFAULT_PROFILE", // Only read if AWS_SDK_LOAD_CONFIG is also set+ }+ sharedCredsFileEnvKey = []string{+ "AWS_SHARED_CREDENTIALS_FILE",+ }+ sharedConfigFileEnvKey = []string{+ "AWS_CONFIG_FILE",+ }+)++// loadEnvConfig retrieves the SDK's environment configuration.+// See `envConfig` for the values that will be retrieved.+//+// If the environment variable `AWS_SDK_LOAD_CONFIG` is set to a truthy value+// the shared SDK config will be loaded in addition to the SDK's specific+// configuration values.+func loadEnvConfig() envConfig {+ enableSharedConfig, _ := strconv.ParseBool(os.Getenv("AWS_SDK_LOAD_CONFIG"))+ return envConfigLoad(enableSharedConfig)+}++// loadEnvSharedConfig retrieves the SDK's environment configuration, and the+// SDK shared config. See `envConfig` for the values that will be retrieved.+//+// Loads the shared configuration in addition to the SDK's specific configuration.+// This will load the same values as `loadEnvConfig` if the `AWS_SDK_LOAD_CONFIG`+// environment variable is set.+func loadSharedEnvConfig() envConfig {+ return envConfigLoad(true)+}++func envConfigLoad(enableSharedConfig bool) envConfig {+ cfg := envConfig{}++ cfg.EnableSharedConfig = enableSharedConfig++ setFromEnvVal(&cfg.Creds.AccessKeyID, credAccessEnvKey)+ setFromEnvVal(&cfg.Creds.SecretAccessKey, credSecretEnvKey)+ setFromEnvVal(&cfg.Creds.SessionToken, credSessionEnvKey)++ // CSM environment variables+ setFromEnvVal(&cfg.csmEnabled, csmEnabledEnvKey)+ setFromEnvVal(&cfg.CSMPort, csmPortEnvKey)+ setFromEnvVal(&cfg.CSMClientID, csmClientIDEnvKey)+ cfg.CSMEnabled = len(cfg.csmEnabled) > 0++ // Require logical grouping of credentials+ if len(cfg.Creds.AccessKeyID) == 0 || len(cfg.Creds.SecretAccessKey) == 0 {+ cfg.Creds = credentials.Value{}+ } else {+ cfg.Creds.ProviderName = EnvProviderName+ }++ regionKeys := regionEnvKeys+ profileKeys := profileEnvKeys+ if !cfg.EnableSharedConfig {+ regionKeys = regionKeys[:1]+ profileKeys = profileKeys[:1]+ }++ setFromEnvVal(&cfg.Region, regionKeys)+ setFromEnvVal(&cfg.Profile, profileKeys)++ // endpoint discovery is in reference to it being enabled.+ setFromEnvVal(&cfg.enableEndpointDiscovery, enableEndpointDiscoveryEnvKey)+ if len(cfg.enableEndpointDiscovery) > 0 {+ cfg.EnableEndpointDiscovery = aws.Bool(cfg.enableEndpointDiscovery != "false")+ }++ setFromEnvVal(&cfg.SharedCredentialsFile, sharedCredsFileEnvKey)+ setFromEnvVal(&cfg.SharedConfigFile, sharedConfigFileEnvKey)++ if len(cfg.SharedCredentialsFile) == 0 {+ cfg.SharedCredentialsFile = defaults.SharedCredentialsFilename()+ }+ if len(cfg.SharedConfigFile) == 0 {+ cfg.SharedConfigFile = defaults.SharedConfigFilename()+ }++ cfg.CustomCABundle = os.Getenv("AWS_CA_BUNDLE")++ return cfg+}++func setFromEnvVal(dst *string, keys []string) {+ for _, k := range keys {+ if v := os.Getenv(k); len(v) > 0 {+ *dst = v+ break+ }+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/session.go b/vendor/github.com/aws/aws-sdk-go/aws/session/session.gonew file mode 100644index 000000000..9bdbafd65--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/session.go@@ -0,0 +1,716 @@+package session++import (+ "crypto/tls"+ "crypto/x509"+ "fmt"+ "io"+ "io/ioutil"+ "net/http"+ "os"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/corehandlers"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/credentials/processcreds"+ "github.com/aws/aws-sdk-go/aws/credentials/stscreds"+ "github.com/aws/aws-sdk-go/aws/csm"+ "github.com/aws/aws-sdk-go/aws/defaults"+ "github.com/aws/aws-sdk-go/aws/endpoints"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/shareddefaults"+)++const (+ // ErrCodeSharedConfig represents an error that occurs in the shared+ // configuration logic+ ErrCodeSharedConfig = "SharedConfigErr"+)++// ErrSharedConfigSourceCollision will be returned if a section contains both+// source_profile and credential_source+var ErrSharedConfigSourceCollision = awserr.New(ErrCodeSharedConfig, "only source profile or credential source can be specified, not both", nil)++// ErrSharedConfigECSContainerEnvVarEmpty will be returned if the environment+// variables are empty and Environment was set as the credential source+var ErrSharedConfigECSContainerEnvVarEmpty = awserr.New(ErrCodeSharedConfig, "EcsContainer was specified as the credential_source, but 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' was not set", nil)++// ErrSharedConfigInvalidCredSource will be returned if an invalid credential source was provided+var ErrSharedConfigInvalidCredSource = awserr.New(ErrCodeSharedConfig, "credential source values must be EcsContainer, Ec2InstanceMetadata, or Environment", nil)++// A Session provides a central location to create service clients from and+// store configurations and request handlers for those services.+//+// Sessions are safe to create service clients concurrently, but it is not safe+// to mutate the Session concurrently.+//+// The Session satisfies the service client's client.ConfigProvider.+type Session struct {+ Config *aws.Config+ Handlers request.Handlers+}++// New creates a new instance of the handlers merging in the provided configs+// on top of the SDK's default configurations. Once the Session is created it+// can be mutated to modify the Config or Handlers. The Session is safe to be+// read concurrently, but it should not be written to concurrently.+//+// If the AWS_SDK_LOAD_CONFIG environment is set to a truthy value, the New+// method could now encounter an error when loading the configuration. When+// The environment variable is set, and an error occurs, New will return a+// session that will fail all requests reporting the error that occurred while+// loading the session. Use NewSession to get the error when creating the+// session.+//+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value+// the shared config file (~/.aws/config) will also be loaded, in addition to+// the shared credentials file (~/.aws/credentials). Values set in both the+// shared config, and shared credentials will be taken from the shared+// credentials file.+//+// Deprecated: Use NewSession functions to create sessions instead. NewSession+// has the same functionality as New except an error can be returned when the+// func is called instead of waiting to receive an error until a request is made.+func New(cfgs ...*aws.Config) *Session {+ // load initial config from environment+ envCfg := loadEnvConfig()++ if envCfg.EnableSharedConfig {+ var cfg aws.Config+ cfg.MergeIn(cfgs...)+ s, err := NewSessionWithOptions(Options{+ Config: cfg,+ SharedConfigState: SharedConfigEnable,+ })+ if err != nil {+ // Old session.New expected all errors to be discovered when+ // a request is made, and would report the errors then. This+ // needs to be replicated if an error occurs while creating+ // the session.+ msg := "failed to create session with AWS_SDK_LOAD_CONFIG enabled. " ++ "Use session.NewSession to handle errors occurring during session creation."++ // Session creation failed, need to report the error and prevent+ // any requests from succeeding.+ s = &Session{Config: defaults.Config()}+ s.Config.MergeIn(cfgs...)+ s.Config.Logger.Log("ERROR:", msg, "Error:", err)+ s.Handlers.Validate.PushBack(func(r *request.Request) {+ r.Error = err+ })+ }++ return s+ }++ s := deprecatedNewSession(cfgs...)+ if envCfg.CSMEnabled {+ enableCSM(&s.Handlers, envCfg.CSMClientID, envCfg.CSMPort, s.Config.Logger)+ }++ return s+}++// NewSession returns a new Session created from SDK defaults, config files,+// environment, and user provided config files. Once the Session is created+// it can be mutated to modify the Config or Handlers. The Session is safe to+// be read concurrently, but it should not be written to concurrently.+//+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value+// the shared config file (~/.aws/config) will also be loaded in addition to+// the shared credentials file (~/.aws/credentials). Values set in both the+// shared config, and shared credentials will be taken from the shared+// credentials file. Enabling the Shared Config will also allow the Session+// to be built with retrieving credentials with AssumeRole set in the config.+//+// See the NewSessionWithOptions func for information on how to override or+// control through code how the Session will be created. Such as specifying the+// config profile, and controlling if shared config is enabled or not.+func NewSession(cfgs ...*aws.Config) (*Session, error) {+ opts := Options{}+ opts.Config.MergeIn(cfgs...)++ return NewSessionWithOptions(opts)+}++// SharedConfigState provides the ability to optionally override the state+// of the session's creation based on the shared config being enabled or+// disabled.+type SharedConfigState int++const (+ // SharedConfigStateFromEnv does not override any state of the+ // AWS_SDK_LOAD_CONFIG env var. It is the default value of the+ // SharedConfigState type.+ SharedConfigStateFromEnv SharedConfigState = iota++ // SharedConfigDisable overrides the AWS_SDK_LOAD_CONFIG env var value+ // and disables the shared config functionality.+ SharedConfigDisable++ // SharedConfigEnable overrides the AWS_SDK_LOAD_CONFIG env var value+ // and enables the shared config functionality.+ SharedConfigEnable+)++// Options provides the means to control how a Session is created and what+// configuration values will be loaded.+//+type Options struct {+ // Provides config values for the SDK to use when creating service clients+ // and making API requests to services. Any value set in with this field+ // will override the associated value provided by the SDK defaults,+ // environment or config files where relevant.+ //+ // If not set, configuration values from from SDK defaults, environment,+ // config will be used.+ Config aws.Config++ // Overrides the config profile the Session should be created from. If not+ // set the value of the environment variable will be loaded (AWS_PROFILE,+ // or AWS_DEFAULT_PROFILE if the Shared Config is enabled).+ //+ // If not set and environment variables are not set the "default"+ // (DefaultSharedConfigProfile) will be used as the profile to load the+ // session config from.+ Profile string++ // Instructs how the Session will be created based on the AWS_SDK_LOAD_CONFIG+ // environment variable. By default a Session will be created using the+ // value provided by the AWS_SDK_LOAD_CONFIG environment variable.+ //+ // Setting this value to SharedConfigEnable or SharedConfigDisable+ // will allow you to override the AWS_SDK_LOAD_CONFIG environment variable+ // and enable or disable the shared config functionality.+ SharedConfigState SharedConfigState++ // Ordered list of files the session will load configuration from.+ // It will override environment variable AWS_SHARED_CREDENTIALS_FILE, AWS_CONFIG_FILE.+ SharedConfigFiles []string++ // When the SDK's shared config is configured to assume a role with MFA+ // this option is required in order to provide the mechanism that will+ // retrieve the MFA token. There is no default value for this field. If+ // it is not set an error will be returned when creating the session.+ //+ // This token provider will be called when ever the assumed role's+ // credentials need to be refreshed. Within the context of service clients+ // all sharing the same session the SDK will ensure calls to the token+ // provider are atomic. When sharing a token provider across multiple+ // sessions additional synchronization logic is needed to ensure the+ // token providers do not introduce race conditions. It is recommend to+ // share the session where possible.+ //+ // stscreds.StdinTokenProvider is a basic implementation that will prompt+ // from stdin for the MFA token code.+ //+ // This field is only used if the shared configuration is enabled, and+ // the config enables assume role wit MFA via the mfa_serial field.+ AssumeRoleTokenProvider func() (string, error)++ // Reader for a custom Credentials Authority (CA) bundle in PEM format that+ // the SDK will use instead of the default system's root CA bundle. Use this+ // only if you want to replace the CA bundle the SDK uses for TLS requests.+ //+ // Enabling this option will attempt to merge the Transport into the SDK's HTTP+ // client. If the client's Transport is not a http.Transport an error will be+ // returned. If the Transport's TLS config is set this option will cause the SDK+ // to overwrite the Transport's TLS config's RootCAs value. If the CA+ // bundle reader contains multiple certificates all of them will be loaded.+ //+ // The Session option CustomCABundle is also available when creating sessions+ // to also enable this feature. CustomCABundle session option field has priority+ // over the AWS_CA_BUNDLE environment variable, and will be used if both are set.+ CustomCABundle io.Reader+}++// NewSessionWithOptions returns a new Session created from SDK defaults, config files,+// environment, and user provided config files. This func uses the Options+// values to configure how the Session is created.+//+// If the AWS_SDK_LOAD_CONFIG environment variable is set to a truthy value+// the shared config file (~/.aws/config) will also be loaded in addition to+// the shared credentials file (~/.aws/credentials). Values set in both the+// shared config, and shared credentials will be taken from the shared+// credentials file. Enabling the Shared Config will also allow the Session+// to be built with retrieving credentials with AssumeRole set in the config.+//+// // Equivalent to session.New+// sess := session.Must(session.NewSessionWithOptions(session.Options{}))+//+// // Specify profile to load for the session's config+// sess := session.Must(session.NewSessionWithOptions(session.Options{+// Profile: "profile_name",+// }))+//+// // Specify profile for config and region for requests+// sess := session.Must(session.NewSessionWithOptions(session.Options{+// Config: aws.Config{Region: aws.String("us-east-1")},+// Profile: "profile_name",+// }))+//+// // Force enable Shared Config support+// sess := session.Must(session.NewSessionWithOptions(session.Options{+// SharedConfigState: session.SharedConfigEnable,+// }))+func NewSessionWithOptions(opts Options) (*Session, error) {+ var envCfg envConfig+ if opts.SharedConfigState == SharedConfigEnable {+ envCfg = loadSharedEnvConfig()+ } else {+ envCfg = loadEnvConfig()+ }++ if len(opts.Profile) > 0 {+ envCfg.Profile = opts.Profile+ }++ switch opts.SharedConfigState {+ case SharedConfigDisable:+ envCfg.EnableSharedConfig = false+ case SharedConfigEnable:+ envCfg.EnableSharedConfig = true+ }++ // Only use AWS_CA_BUNDLE if session option is not provided.+ if len(envCfg.CustomCABundle) != 0 && opts.CustomCABundle == nil {+ f, err := os.Open(envCfg.CustomCABundle)+ if err != nil {+ return nil, awserr.New("LoadCustomCABundleError",+ "failed to open custom CA bundle PEM file", err)+ }+ defer f.Close()+ opts.CustomCABundle = f+ }++ return newSession(opts, envCfg, &opts.Config)+}++// Must is a helper function to ensure the Session is valid and there was no+// error when calling a NewSession function.+//+// This helper is intended to be used in variable initialization to load the+// Session and configuration at startup. Such as:+//+// var sess = session.Must(session.NewSession())+func Must(sess *Session, err error) *Session {+ if err != nil {+ panic(err)+ }++ return sess+}++func deprecatedNewSession(cfgs ...*aws.Config) *Session {+ cfg := defaults.Config()+ handlers := defaults.Handlers()++ // Apply the passed in configs so the configuration can be applied to the+ // default credential chain+ cfg.MergeIn(cfgs...)+ if cfg.EndpointResolver == nil {+ // An endpoint resolver is required for a session to be able to provide+ // endpoints for service client configurations.+ cfg.EndpointResolver = endpoints.DefaultResolver()+ }+ cfg.Credentials = defaults.CredChain(cfg, handlers)++ // Reapply any passed in configs to override credentials if set+ cfg.MergeIn(cfgs...)++ s := &Session{+ Config: cfg,+ Handlers: handlers,+ }++ initHandlers(s)+ return s+}++func enableCSM(handlers *request.Handlers, clientID string, port string, logger aws.Logger) {+ logger.Log("Enabling CSM")+ if len(port) == 0 {+ port = csm.DefaultPort+ }++ r, err := csm.Start(clientID, "127.0.0.1:"+port)+ if err != nil {+ return+ }+ r.InjectHandlers(handlers)+}++func newSession(opts Options, envCfg envConfig, cfgs ...*aws.Config) (*Session, error) {+ cfg := defaults.Config()+ handlers := defaults.Handlers()++ // Get a merged version of the user provided config to determine if+ // credentials were.+ userCfg := &aws.Config{}+ userCfg.MergeIn(cfgs...)++ // Ordered config files will be loaded in with later files overwriting+ // previous config file values.+ var cfgFiles []string+ if opts.SharedConfigFiles != nil {+ cfgFiles = opts.SharedConfigFiles+ } else {+ cfgFiles = []string{envCfg.SharedConfigFile, envCfg.SharedCredentialsFile}+ if !envCfg.EnableSharedConfig {+ // The shared config file (~/.aws/config) is only loaded if instructed+ // to load via the envConfig.EnableSharedConfig (AWS_SDK_LOAD_CONFIG).+ cfgFiles = cfgFiles[1:]+ }+ }++ // Load additional config from file(s)+ sharedCfg, err := loadSharedConfig(envCfg.Profile, cfgFiles)+ if err != nil {+ return nil, err+ }++ if err := mergeConfigSrcs(cfg, userCfg, envCfg, sharedCfg, handlers, opts); err != nil {+ return nil, err+ }++ s := &Session{+ Config: cfg,+ Handlers: handlers,+ }++ initHandlers(s)+ if envCfg.CSMEnabled {+ enableCSM(&s.Handlers, envCfg.CSMClientID, envCfg.CSMPort, s.Config.Logger)+ }++ // Setup HTTP client with custom cert bundle if enabled+ if opts.CustomCABundle != nil {+ if err := loadCustomCABundle(s, opts.CustomCABundle); err != nil {+ return nil, err+ }+ }++ return s, nil+}++func loadCustomCABundle(s *Session, bundle io.Reader) error {+ var t *http.Transport+ switch v := s.Config.HTTPClient.Transport.(type) {+ case *http.Transport:+ t = v+ default:+ if s.Config.HTTPClient.Transport != nil {+ return awserr.New("LoadCustomCABundleError",+ "unable to load custom CA bundle, HTTPClient's transport unsupported type", nil)+ }+ }+ if t == nil {+ t = &http.Transport{}+ }++ p, err := loadCertPool(bundle)+ if err != nil {+ return err+ }+ if t.TLSClientConfig == nil {+ t.TLSClientConfig = &tls.Config{}+ }+ t.TLSClientConfig.RootCAs = p++ s.Config.HTTPClient.Transport = t++ return nil+}++func loadCertPool(r io.Reader) (*x509.CertPool, error) {+ b, err := ioutil.ReadAll(r)+ if err != nil {+ return nil, awserr.New("LoadCustomCABundleError",+ "failed to read custom CA bundle PEM file", err)+ }++ p := x509.NewCertPool()+ if !p.AppendCertsFromPEM(b) {+ return nil, awserr.New("LoadCustomCABundleError",+ "failed to load custom CA bundle PEM file", err)+ }++ return p, nil+}++func mergeConfigSrcs(cfg, userCfg *aws.Config, envCfg envConfig, sharedCfg sharedConfig, handlers request.Handlers, sessOpts Options) error {+ // Merge in user provided configuration+ cfg.MergeIn(userCfg)++ // Region if not already set by user+ if len(aws.StringValue(cfg.Region)) == 0 {+ if len(envCfg.Region) > 0 {+ cfg.WithRegion(envCfg.Region)+ } else if envCfg.EnableSharedConfig && len(sharedCfg.Region) > 0 {+ cfg.WithRegion(sharedCfg.Region)+ }+ }++ if cfg.EnableEndpointDiscovery == nil {+ if envCfg.EnableEndpointDiscovery != nil {+ cfg.WithEndpointDiscovery(*envCfg.EnableEndpointDiscovery)+ } else if envCfg.EnableSharedConfig && sharedCfg.EnableEndpointDiscovery != nil {+ cfg.WithEndpointDiscovery(*sharedCfg.EnableEndpointDiscovery)+ }+ }++ // Configure credentials if not already set+ if cfg.Credentials == credentials.AnonymousCredentials && userCfg.Credentials == nil {++ // inspect the profile to see if a credential source has been specified.+ if envCfg.EnableSharedConfig && len(sharedCfg.AssumeRole.CredentialSource) > 0 {++ // if both credential_source and source_profile have been set, return an error+ // as this is undefined behavior.+ if len(sharedCfg.AssumeRole.SourceProfile) > 0 {+ return ErrSharedConfigSourceCollision+ }++ // valid credential source values+ const (+ credSourceEc2Metadata = "Ec2InstanceMetadata"+ credSourceEnvironment = "Environment"+ credSourceECSContainer = "EcsContainer"+ )++ switch sharedCfg.AssumeRole.CredentialSource {+ case credSourceEc2Metadata:+ cfgCp := *cfg+ p := defaults.RemoteCredProvider(cfgCp, handlers)+ cfgCp.Credentials = credentials.NewCredentials(p)++ if len(sharedCfg.AssumeRole.MFASerial) > 0 && sessOpts.AssumeRoleTokenProvider == nil {+ // AssumeRole Token provider is required if doing Assume Role+ // with MFA.+ return AssumeRoleTokenProviderNotSetError{}+ }++ cfg.Credentials = assumeRoleCredentials(cfgCp, handlers, sharedCfg, sessOpts)+ case credSourceEnvironment:+ cfg.Credentials = credentials.NewStaticCredentialsFromCreds(+ envCfg.Creds,+ )+ case credSourceECSContainer:+ if len(os.Getenv(shareddefaults.ECSCredsProviderEnvVar)) == 0 {+ return ErrSharedConfigECSContainerEnvVarEmpty+ }++ cfgCp := *cfg+ p := defaults.RemoteCredProvider(cfgCp, handlers)+ creds := credentials.NewCredentials(p)++ cfg.Credentials = creds+ default:+ return ErrSharedConfigInvalidCredSource+ }++ return nil+ }++ if len(envCfg.Creds.AccessKeyID) > 0 {+ cfg.Credentials = credentials.NewStaticCredentialsFromCreds(+ envCfg.Creds,+ )+ } else if envCfg.EnableSharedConfig && len(sharedCfg.AssumeRole.RoleARN) > 0 && sharedCfg.AssumeRoleSource != nil {+ cfgCp := *cfg+ cfgCp.Credentials = credentials.NewStaticCredentialsFromCreds(+ sharedCfg.AssumeRoleSource.Creds,+ )++ if len(sharedCfg.AssumeRole.MFASerial) > 0 && sessOpts.AssumeRoleTokenProvider == nil {+ // AssumeRole Token provider is required if doing Assume Role+ // with MFA.+ return AssumeRoleTokenProviderNotSetError{}+ }++ cfg.Credentials = assumeRoleCredentials(cfgCp, handlers, sharedCfg, sessOpts)+ } else if len(sharedCfg.Creds.AccessKeyID) > 0 {+ cfg.Credentials = credentials.NewStaticCredentialsFromCreds(+ sharedCfg.Creds,+ )+ } else if len(sharedCfg.CredentialProcess) > 0 {+ cfg.Credentials = processcreds.NewCredentials(+ sharedCfg.CredentialProcess,+ )+ } else {+ // Fallback to default credentials provider, include mock errors+ // for the credential chain so user can identify why credentials+ // failed to be retrieved.+ cfg.Credentials = credentials.NewCredentials(&credentials.ChainProvider{+ VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors),+ Providers: []credentials.Provider{+ &credProviderError{Err: awserr.New("EnvAccessKeyNotFound", "failed to find credentials in the environment.", nil)},+ &credProviderError{Err: awserr.New("SharedCredsLoad", fmt.Sprintf("failed to load profile, %s.", envCfg.Profile), nil)},+ defaults.RemoteCredProvider(*cfg, handlers),+ },+ })+ }+ }++ return nil+}++func assumeRoleCredentials(cfg aws.Config, handlers request.Handlers, sharedCfg sharedConfig, sessOpts Options) *credentials.Credentials {+ return stscreds.NewCredentials(+ &Session{+ Config: &cfg,+ Handlers: handlers.Copy(),+ },+ sharedCfg.AssumeRole.RoleARN,+ func(opt *stscreds.AssumeRoleProvider) {+ opt.RoleSessionName = sharedCfg.AssumeRole.RoleSessionName++ // Assume role with external ID+ if len(sharedCfg.AssumeRole.ExternalID) > 0 {+ opt.ExternalID = aws.String(sharedCfg.AssumeRole.ExternalID)+ }++ // Assume role with MFA+ if len(sharedCfg.AssumeRole.MFASerial) > 0 {+ opt.SerialNumber = aws.String(sharedCfg.AssumeRole.MFASerial)+ opt.TokenProvider = sessOpts.AssumeRoleTokenProvider+ }+ },+ )+}++// AssumeRoleTokenProviderNotSetError is an error returned when creating a session when the+// MFAToken option is not set when shared config is configured load assume a+// role with an MFA token.+type AssumeRoleTokenProviderNotSetError struct{}++// Code is the short id of the error.+func (e AssumeRoleTokenProviderNotSetError) Code() string {+ return "AssumeRoleTokenProviderNotSetError"+}++// Message is the description of the error+func (e AssumeRoleTokenProviderNotSetError) Message() string {+ return fmt.Sprintf("assume role with MFA enabled, but AssumeRoleTokenProvider session option not set.")+}++// OrigErr is the underlying error that caused the failure.+func (e AssumeRoleTokenProviderNotSetError) OrigErr() error {+ return nil+}++// Error satisfies the error interface.+func (e AssumeRoleTokenProviderNotSetError) Error() string {+ return awserr.SprintError(e.Code(), e.Message(), "", nil)+}++type credProviderError struct {+ Err error+}++var emptyCreds = credentials.Value{}++func (c credProviderError) Retrieve() (credentials.Value, error) {+ return credentials.Value{}, c.Err+}+func (c credProviderError) IsExpired() bool {+ return true+}++func initHandlers(s *Session) {+ // Add the Validate parameter handler if it is not disabled.+ s.Handlers.Validate.Remove(corehandlers.ValidateParametersHandler)+ if !aws.BoolValue(s.Config.DisableParamValidation) {+ s.Handlers.Validate.PushBackNamed(corehandlers.ValidateParametersHandler)+ }+}++// Copy creates and returns a copy of the current Session, coping the config+// and handlers. If any additional configs are provided they will be merged+// on top of the Session's copied config.+//+// // Create a copy of the current Session, configured for the us-west-2 region.+// sess.Copy(&aws.Config{Region: aws.String("us-west-2")})+func (s *Session) Copy(cfgs ...*aws.Config) *Session {+ newSession := &Session{+ Config: s.Config.Copy(cfgs...),+ Handlers: s.Handlers.Copy(),+ }++ initHandlers(newSession)++ return newSession+}++// ClientConfig satisfies the client.ConfigProvider interface and is used to+// configure the service client instances. Passing the Session to the service+// client's constructor (New) will use this method to configure the client.+func (s *Session) ClientConfig(serviceName string, cfgs ...*aws.Config) client.Config {+ // Backwards compatibility, the error will be eaten if user calls ClientConfig+ // directly. All SDK services will use ClientconfigWithError.+ cfg, _ := s.clientConfigWithErr(serviceName, cfgs...)++ return cfg+}++func (s *Session) clientConfigWithErr(serviceName string, cfgs ...*aws.Config) (client.Config, error) {+ s = s.Copy(cfgs...)++ var resolved endpoints.ResolvedEndpoint+ var err error++ region := aws.StringValue(s.Config.Region)++ if endpoint := aws.StringValue(s.Config.Endpoint); len(endpoint) != 0 {+ resolved.URL = endpoints.AddScheme(endpoint, aws.BoolValue(s.Config.DisableSSL))+ resolved.SigningRegion = region+ } else {+ resolved, err = s.Config.EndpointResolver.EndpointFor(+ serviceName, region,+ func(opt *endpoints.Options) {+ opt.DisableSSL = aws.BoolValue(s.Config.DisableSSL)+ opt.UseDualStack = aws.BoolValue(s.Config.UseDualStack)++ // Support the condition where the service is modeled but its+ // endpoint metadata is not available.+ opt.ResolveUnknownService = true+ },+ )+ }++ return client.Config{+ Config: s.Config,+ Handlers: s.Handlers,+ Endpoint: resolved.URL,+ SigningRegion: resolved.SigningRegion,+ SigningNameDerived: resolved.SigningNameDerived,+ SigningName: resolved.SigningName,+ }, err+}++// ClientConfigNoResolveEndpoint is the same as ClientConfig with the exception+// that the EndpointResolver will not be used to resolve the endpoint. The only+// endpoint set must come from the aws.Config.Endpoint field.+func (s *Session) ClientConfigNoResolveEndpoint(cfgs ...*aws.Config) client.Config {+ s = s.Copy(cfgs...)++ var resolved endpoints.ResolvedEndpoint++ region := aws.StringValue(s.Config.Region)++ if ep := aws.StringValue(s.Config.Endpoint); len(ep) > 0 {+ resolved.URL = endpoints.AddScheme(ep, aws.BoolValue(s.Config.DisableSSL))+ resolved.SigningRegion = region+ }++ return client.Config{+ Config: s.Config,+ Handlers: s.Handlers,+ Endpoint: resolved.URL,+ SigningRegion: resolved.SigningRegion,+ SigningNameDerived: resolved.SigningNameDerived,+ SigningName: resolved.SigningName,+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.go b/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.gonew file mode 100644index 000000000..7cb44021b--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/session/shared_config.go@@ -0,0 +1,329 @@+package session++import (+ "fmt"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/credentials"++ "github.com/aws/aws-sdk-go/internal/ini"+)++const (+ // Static Credentials group+ accessKeyIDKey = `aws_access_key_id` // group required+ secretAccessKey = `aws_secret_access_key` // group required+ sessionTokenKey = `aws_session_token` // optional++ // Assume Role Credentials group+ roleArnKey = `role_arn` // group required+ sourceProfileKey = `source_profile` // group required (or credential_source)+ credentialSourceKey = `credential_source` // group required (or source_profile)+ externalIDKey = `external_id` // optional+ mfaSerialKey = `mfa_serial` // optional+ roleSessionNameKey = `role_session_name` // optional++ // Additional Config fields+ regionKey = `region`++ // endpoint discovery group+ enableEndpointDiscoveryKey = `endpoint_discovery_enabled` // optional+ // External Credential Process+ credentialProcessKey = `credential_process`++ // DefaultSharedConfigProfile is the default profile to be used when+ // loading configuration from the config files if another profile name+ // is not provided.+ DefaultSharedConfigProfile = `default`+)++type assumeRoleConfig struct {+ RoleARN string+ SourceProfile string+ CredentialSource string+ ExternalID string+ MFASerial string+ RoleSessionName string+}++// sharedConfig represents the configuration fields of the SDK config files.+type sharedConfig struct {+ // Credentials values from the config file. Both aws_access_key_id+ // and aws_secret_access_key must be provided together in the same file+ // to be considered valid. The values will be ignored if not a complete group.+ // aws_session_token is an optional field that can be provided if both of the+ // other two fields are also provided.+ //+ // aws_access_key_id+ // aws_secret_access_key+ // aws_session_token+ Creds credentials.Value++ AssumeRole assumeRoleConfig+ AssumeRoleSource *sharedConfig++ // An external process to request credentials+ CredentialProcess string++ // Region is the region the SDK should use for looking up AWS service endpoints+ // and signing requests.+ //+ // region+ Region string++ // EnableEndpointDiscovery can be enabled in the shared config by setting+ // endpoint_discovery_enabled to true+ //+ // endpoint_discovery_enabled = true+ EnableEndpointDiscovery *bool+}++type sharedConfigFile struct {+ Filename string+ IniData ini.Sections+}++// loadSharedConfig retrieves the configuration from the list of files+// using the profile provided. The order the files are listed will determine+// precedence. Values in subsequent files will overwrite values defined in+// earlier files.+//+// For example, given two files A and B. Both define credentials. If the order+// of the files are A then B, B's credential values will be used instead of A's.+//+// See sharedConfig.setFromFile for information how the config files+// will be loaded.+func loadSharedConfig(profile string, filenames []string) (sharedConfig, error) {+ if len(profile) == 0 {+ profile = DefaultSharedConfigProfile+ }++ files, err := loadSharedConfigIniFiles(filenames)+ if err != nil {+ return sharedConfig{}, err+ }++ cfg := sharedConfig{}+ if err = cfg.setFromIniFiles(profile, files); err != nil {+ return sharedConfig{}, err+ }++ if len(cfg.AssumeRole.SourceProfile) > 0 {+ if err := cfg.setAssumeRoleSource(profile, files); err != nil {+ return sharedConfig{}, err+ }+ }++ return cfg, nil+}++func loadSharedConfigIniFiles(filenames []string) ([]sharedConfigFile, error) {+ files := make([]sharedConfigFile, 0, len(filenames))++ for _, filename := range filenames {+ sections, err := ini.OpenFile(filename)+ if aerr, ok := err.(awserr.Error); ok && aerr.Code() == ini.ErrCodeUnableToReadFile {+ // Skip files which can't be opened and read for whatever reason+ continue+ } else if err != nil {+ return nil, SharedConfigLoadError{Filename: filename, Err: err}+ }++ files = append(files, sharedConfigFile{+ Filename: filename, IniData: sections,+ })+ }++ return files, nil+}++func (cfg *sharedConfig) setAssumeRoleSource(origProfile string, files []sharedConfigFile) error {+ var assumeRoleSrc sharedConfig++ if len(cfg.AssumeRole.CredentialSource) > 0 {+ // setAssumeRoleSource is only called when source_profile is found.+ // If both source_profile and credential_source are set, then+ // ErrSharedConfigSourceCollision will be returned+ return ErrSharedConfigSourceCollision+ }++ // Multiple level assume role chains are not support+ if cfg.AssumeRole.SourceProfile == origProfile {+ assumeRoleSrc = *cfg+ assumeRoleSrc.AssumeRole = assumeRoleConfig{}+ } else {+ err := assumeRoleSrc.setFromIniFiles(cfg.AssumeRole.SourceProfile, files)+ if err != nil {+ return err+ }+ }++ if len(assumeRoleSrc.Creds.AccessKeyID) == 0 {+ return SharedConfigAssumeRoleError{RoleARN: cfg.AssumeRole.RoleARN}+ }++ cfg.AssumeRoleSource = &assumeRoleSrc++ return nil+}++func (cfg *sharedConfig) setFromIniFiles(profile string, files []sharedConfigFile) error {+ // Trim files from the list that don't exist.+ for _, f := range files {+ if err := cfg.setFromIniFile(profile, f); err != nil {+ if _, ok := err.(SharedConfigProfileNotExistsError); ok {+ // Ignore proviles missings+ continue+ }+ return err+ }+ }++ return nil+}++// setFromFile loads the configuration from the file using+// the profile provided. A sharedConfig pointer type value is used so that+// multiple config file loadings can be chained.+//+// Only loads complete logically grouped values, and will not set fields in cfg+// for incomplete grouped values in the config. Such as credentials. For example+// if a config file only includes aws_access_key_id but no aws_secret_access_key+// the aws_access_key_id will be ignored.+func (cfg *sharedConfig) setFromIniFile(profile string, file sharedConfigFile) error {+ section, ok := file.IniData.GetSection(profile)+ if !ok {+ // Fallback to to alternate profile name: profile <name>+ section, ok = file.IniData.GetSection(fmt.Sprintf("profile %s", profile))+ if !ok {+ return SharedConfigProfileNotExistsError{Profile: profile, Err: nil}+ }+ }++ // Shared Credentials+ akid := section.String(accessKeyIDKey)+ secret := section.String(secretAccessKey)+ if len(akid) > 0 && len(secret) > 0 {+ cfg.Creds = credentials.Value{+ AccessKeyID: akid,+ SecretAccessKey: secret,+ SessionToken: section.String(sessionTokenKey),+ ProviderName: fmt.Sprintf("SharedConfigCredentials: %s", file.Filename),+ }+ }++ // Assume Role+ roleArn := section.String(roleArnKey)+ srcProfile := section.String(sourceProfileKey)+ credentialSource := section.String(credentialSourceKey)+ hasSource := len(srcProfile) > 0 || len(credentialSource) > 0+ if len(roleArn) > 0 && hasSource {+ cfg.AssumeRole = assumeRoleConfig{+ RoleARN: roleArn,+ SourceProfile: srcProfile,+ CredentialSource: credentialSource,+ ExternalID: section.String(externalIDKey),+ MFASerial: section.String(mfaSerialKey),+ RoleSessionName: section.String(roleSessionNameKey),+ }+ }++ // `credential_process`+ if credProc := section.String(credentialProcessKey); len(credProc) > 0 {+ cfg.CredentialProcess = credProc+ }++ // Region+ if v := section.String(regionKey); len(v) > 0 {+ cfg.Region = v+ }++ // Endpoint discovery+ if section.Has(enableEndpointDiscoveryKey) {+ v := section.Bool(enableEndpointDiscoveryKey)+ cfg.EnableEndpointDiscovery = &v+ }++ return nil+}++// SharedConfigLoadError is an error for the shared config file failed to load.+type SharedConfigLoadError struct {+ Filename string+ Err error+}++// Code is the short id of the error.+func (e SharedConfigLoadError) Code() string {+ return "SharedConfigLoadError"+}++// Message is the description of the error+func (e SharedConfigLoadError) Message() string {+ return fmt.Sprintf("failed to load config file, %s", e.Filename)+}++// OrigErr is the underlying error that caused the failure.+func (e SharedConfigLoadError) OrigErr() error {+ return e.Err+}++// Error satisfies the error interface.+func (e SharedConfigLoadError) Error() string {+ return awserr.SprintError(e.Code(), e.Message(), "", e.Err)+}++// SharedConfigProfileNotExistsError is an error for the shared config when+// the profile was not find in the config file.+type SharedConfigProfileNotExistsError struct {+ Profile string+ Err error+}++// Code is the short id of the error.+func (e SharedConfigProfileNotExistsError) Code() string {+ return "SharedConfigProfileNotExistsError"+}++// Message is the description of the error+func (e SharedConfigProfileNotExistsError) Message() string {+ return fmt.Sprintf("failed to get profile, %s", e.Profile)+}++// OrigErr is the underlying error that caused the failure.+func (e SharedConfigProfileNotExistsError) OrigErr() error {+ return e.Err+}++// Error satisfies the error interface.+func (e SharedConfigProfileNotExistsError) Error() string {+ return awserr.SprintError(e.Code(), e.Message(), "", e.Err)+}++// SharedConfigAssumeRoleError is an error for the shared config when the+// profile contains assume role information, but that information is invalid+// or not complete.+type SharedConfigAssumeRoleError struct {+ RoleARN string+}++// Code is the short id of the error.+func (e SharedConfigAssumeRoleError) Code() string {+ return "SharedConfigAssumeRoleError"+}++// Message is the description of the error+func (e SharedConfigAssumeRoleError) Message() string {+ return fmt.Sprintf("failed to load assume role for %s, source profile has no shared credentials",+ e.RoleARN)+}++// OrigErr is the underlying error that caused the failure.+func (e SharedConfigAssumeRoleError) OrigErr() error {+ return nil+}++// Error satisfies the error interface.+func (e SharedConfigAssumeRoleError) Error() string {+ return awserr.SprintError(e.Code(), e.Message(), "", nil)+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.gonew file mode 100644index 000000000..244c86da0--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/header_rules.go@@ -0,0 +1,82 @@+package v4++import (+ "net/http"+ "strings"+)++// validator houses a set of rule needed for validation of a+// string value+type rules []rule++// rule interface allows for more flexible rules and just simply+// checks whether or not a value adheres to that rule+type rule interface {+ IsValid(value string) bool+}++// IsValid will iterate through all rules and see if any rules+// apply to the value and supports nested rules+func (r rules) IsValid(value string) bool {+ for _, rule := range r {+ if rule.IsValid(value) {+ return true+ }+ }+ return false+}++// mapRule generic rule for maps+type mapRule map[string]struct{}++// IsValid for the map rule satisfies whether it exists in the map+func (m mapRule) IsValid(value string) bool {+ _, ok := m[value]+ return ok+}++// whitelist is a generic rule for whitelisting+type whitelist struct {+ rule+}++// IsValid for whitelist checks if the value is within the whitelist+func (w whitelist) IsValid(value string) bool {+ return w.rule.IsValid(value)+}++// blacklist is a generic rule for blacklisting+type blacklist struct {+ rule+}++// IsValid for whitelist checks if the value is within the whitelist+func (b blacklist) IsValid(value string) bool {+ return !b.rule.IsValid(value)+}++type patterns []string++// IsValid for patterns checks each pattern and returns if a match has+// been found+func (p patterns) IsValid(value string) bool {+ for _, pattern := range p {+ if strings.HasPrefix(http.CanonicalHeaderKey(value), pattern) {+ return true+ }+ }+ return false+}++// inclusiveRules rules allow for rules to depend on one another+type inclusiveRules []rule++// IsValid will return true if all rules are true+func (r inclusiveRules) IsValid(value string) bool {+ for _, rule := range r {+ if !rule.IsValid(value) {+ return false+ }+ }+ return true+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.gonew file mode 100644index 000000000..6aa2ed241--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go@@ -0,0 +1,7 @@+package v4++// WithUnsignedPayload will enable and set the UnsignedPayload field to+// true of the signer.+func WithUnsignedPayload(v4 *Signer) {+ v4.UnsignedPayload = true+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.gonew file mode 100644index 000000000..bd082e9d1--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go@@ -0,0 +1,24 @@+// +build go1.5++package v4++import (+ "net/url"+ "strings"+)++func getURIPath(u *url.URL) string {+ var uri string++ if len(u.Opaque) > 0 {+ uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/")+ } else {+ uri = u.EscapedPath()+ }++ if len(uri) == 0 {+ uri = "/"+ }++ return uri+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.go b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.gonew file mode 100644index 000000000..594db5b17--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/signer/v4/v4.go@@ -0,0 +1,796 @@+// Package v4 implements signing for AWS V4 signer+//+// Provides request signing for request that need to be signed with+// AWS V4 Signatures.+//+// Standalone Signer+//+// Generally using the signer outside of the SDK should not require any additional+// logic when using Go v1.5 or higher. The signer does this by taking advantage+// of the URL.EscapedPath method. If your request URI requires additional escaping+// you many need to use the URL.Opaque to define what the raw URI should be sent+// to the service as.+//+// The signer will first check the URL.Opaque field, and use its value if set.+// The signer does require the URL.Opaque field to be set in the form of:+//+// "//<hostname>/<path>"+//+// // e.g.+// "//example.com/some/path"+//+// The leading "//" and hostname are required or the URL.Opaque escaping will+// not work correctly.+//+// If URL.Opaque is not set the signer will fallback to the URL.EscapedPath()+// method and using the returned value. If you're using Go v1.4 you must set+// URL.Opaque if the URI path needs escaping. If URL.Opaque is not set with+// Go v1.5 the signer will fallback to URL.Path.+//+// AWS v4 signature validation requires that the canonical string's URI path+// element must be the URI escaped form of the HTTP request's path.+// http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html+//+// The Go HTTP client will perform escaping automatically on the request. Some+// of these escaping may cause signature validation errors because the HTTP+// request differs from the URI path or query that the signature was generated.+// https://golang.org/pkg/net/url/#URL.EscapedPath+//+// Because of this, it is recommended that when using the signer outside of the+// SDK that explicitly escaping the request prior to being signed is preferable,+// and will help prevent signature validation errors. This can be done by setting+// the URL.Opaque or URL.RawPath. The SDK will use URL.Opaque first and then+// call URL.EscapedPath() if Opaque is not set.+//+// If signing a request intended for HTTP2 server, and you're using Go 1.6.2+// through 1.7.4 you should use the URL.RawPath as the pre-escaped form of the+// request URL. https://github.com/golang/go/issues/16847 points to a bug in+// Go pre 1.8 that fails to make HTTP2 requests using absolute URL in the HTTP+// message. URL.Opaque generally will force Go to make requests with absolute URL.+// URL.RawPath does not do this, but RawPath must be a valid escaping of Path+// or url.EscapedPath will ignore the RawPath escaping.+//+// Test `TestStandaloneSign` provides a complete example of using the signer+// outside of the SDK and pre-escaping the URI path.+package v4++import (+ "crypto/hmac"+ "crypto/sha256"+ "encoding/hex"+ "fmt"+ "io"+ "io/ioutil"+ "net/http"+ "net/url"+ "sort"+ "strconv"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/credentials"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/sdkio"+ "github.com/aws/aws-sdk-go/private/protocol/rest"+)++const (+ authHeaderPrefix = "AWS4-HMAC-SHA256"+ timeFormat = "20060102T150405Z"+ shortTimeFormat = "20060102"++ // emptyStringSHA256 is a SHA256 of an empty string+ emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`+)++var ignoredHeaders = rules{+ blacklist{+ mapRule{+ "Authorization": struct{}{},+ "User-Agent": struct{}{},+ "X-Amzn-Trace-Id": struct{}{},+ },+ },+}++// requiredSignedHeaders is a whitelist for build canonical headers.+var requiredSignedHeaders = rules{+ whitelist{+ mapRule{+ "Cache-Control": struct{}{},+ "Content-Disposition": struct{}{},+ "Content-Encoding": struct{}{},+ "Content-Language": struct{}{},+ "Content-Md5": struct{}{},+ "Content-Type": struct{}{},+ "Expires": struct{}{},+ "If-Match": struct{}{},+ "If-Modified-Since": struct{}{},+ "If-None-Match": struct{}{},+ "If-Unmodified-Since": struct{}{},+ "Range": struct{}{},+ "X-Amz-Acl": struct{}{},+ "X-Amz-Copy-Source": struct{}{},+ "X-Amz-Copy-Source-If-Match": struct{}{},+ "X-Amz-Copy-Source-If-Modified-Since": struct{}{},+ "X-Amz-Copy-Source-If-None-Match": struct{}{},+ "X-Amz-Copy-Source-If-Unmodified-Since": struct{}{},+ "X-Amz-Copy-Source-Range": struct{}{},+ "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm": struct{}{},+ "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key": struct{}{},+ "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-Md5": struct{}{},+ "X-Amz-Grant-Full-control": struct{}{},+ "X-Amz-Grant-Read": struct{}{},+ "X-Amz-Grant-Read-Acp": struct{}{},+ "X-Amz-Grant-Write": struct{}{},+ "X-Amz-Grant-Write-Acp": struct{}{},+ "X-Amz-Metadata-Directive": struct{}{},+ "X-Amz-Mfa": struct{}{},+ "X-Amz-Request-Payer": struct{}{},+ "X-Amz-Server-Side-Encryption": struct{}{},+ "X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id": struct{}{},+ "X-Amz-Server-Side-Encryption-Customer-Algorithm": struct{}{},+ "X-Amz-Server-Side-Encryption-Customer-Key": struct{}{},+ "X-Amz-Server-Side-Encryption-Customer-Key-Md5": struct{}{},+ "X-Amz-Storage-Class": struct{}{},+ "X-Amz-Tagging": struct{}{},+ "X-Amz-Website-Redirect-Location": struct{}{},+ "X-Amz-Content-Sha256": struct{}{},+ },+ },+ patterns{"X-Amz-Meta-"},+}++// allowedHoisting is a whitelist for build query headers. The boolean value+// represents whether or not it is a pattern.+var allowedQueryHoisting = inclusiveRules{+ blacklist{requiredSignedHeaders},+ patterns{"X-Amz-"},+}++// Signer applies AWS v4 signing to given request. Use this to sign requests+// that need to be signed with AWS V4 Signatures.+type Signer struct {+ // The authentication credentials the request will be signed against.+ // This value must be set to sign requests.+ Credentials *credentials.Credentials++ // Sets the log level the signer should use when reporting information to+ // the logger. If the logger is nil nothing will be logged. See+ // aws.LogLevelType for more information on available logging levels+ //+ // By default nothing will be logged.+ Debug aws.LogLevelType++ // The logger loging information will be written to. If there the logger+ // is nil, nothing will be logged.+ Logger aws.Logger++ // Disables the Signer's moving HTTP header key/value pairs from the HTTP+ // request header to the request's query string. This is most commonly used+ // with pre-signed requests preventing headers from being added to the+ // request's query string.+ DisableHeaderHoisting bool++ // Disables the automatic escaping of the URI path of the request for the+ // siganture's canonical string's path. For services that do not need additional+ // escaping then use this to disable the signer escaping the path.+ //+ // S3 is an example of a service that does not need additional escaping.+ //+ // http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html+ DisableURIPathEscaping bool++ // Disales the automatical setting of the HTTP request's Body field with the+ // io.ReadSeeker passed in to the signer. This is useful if you're using a+ // custom wrapper around the body for the io.ReadSeeker and want to preserve+ // the Body value on the Request.Body.+ //+ // This does run the risk of signing a request with a body that will not be+ // sent in the request. Need to ensure that the underlying data of the Body+ // values are the same.+ DisableRequestBodyOverwrite bool++ // currentTimeFn returns the time value which represents the current time.+ // This value should only be used for testing. If it is nil the default+ // time.Now will be used.+ currentTimeFn func() time.Time++ // UnsignedPayload will prevent signing of the payload. This will only+ // work for services that have support for this.+ UnsignedPayload bool+}++// NewSigner returns a Signer pointer configured with the credentials and optional+// option values provided. If not options are provided the Signer will use its+// default configuration.+func NewSigner(credentials *credentials.Credentials, options ...func(*Signer)) *Signer {+ v4 := &Signer{+ Credentials: credentials,+ }++ for _, option := range options {+ option(v4)+ }++ return v4+}++type signingCtx struct {+ ServiceName string+ Region string+ Request *http.Request+ Body io.ReadSeeker+ Query url.Values+ Time time.Time+ ExpireTime time.Duration+ SignedHeaderVals http.Header++ DisableURIPathEscaping bool++ credValues credentials.Value+ isPresign bool+ formattedTime string+ formattedShortTime string+ unsignedPayload bool++ bodyDigest string+ signedHeaders string+ canonicalHeaders string+ canonicalString string+ credentialString string+ stringToSign string+ signature string+ authorization string+}++// Sign signs AWS v4 requests with the provided body, service name, region the+// request is made to, and time the request is signed at. The signTime allows+// you to specify that a request is signed for the future, and cannot be+// used until then.+//+// Returns a list of HTTP headers that were included in the signature or an+// error if signing the request failed. Generally for signed requests this value+// is not needed as the full request context will be captured by the http.Request+// value. It is included for reference though.+//+// Sign will set the request's Body to be the `body` parameter passed in. If+// the body is not already an io.ReadCloser, it will be wrapped within one. If+// a `nil` body parameter passed to Sign, the request's Body field will be+// also set to nil. Its important to note that this functionality will not+// change the request's ContentLength of the request.+//+// Sign differs from Presign in that it will sign the request using HTTP+// header values. This type of signing is intended for http.Request values that+// will not be shared, or are shared in a way the header values on the request+// will not be lost.+//+// The requests body is an io.ReadSeeker so the SHA256 of the body can be+// generated. To bypass the signer computing the hash you can set the+// "X-Amz-Content-Sha256" header with a precomputed value. The signer will+// only compute the hash if the request header value is empty.+func (v4 Signer) Sign(r *http.Request, body io.ReadSeeker, service, region string, signTime time.Time) (http.Header, error) {+ return v4.signWithBody(r, body, service, region, 0, false, signTime)+}++// Presign signs AWS v4 requests with the provided body, service name, region+// the request is made to, and time the request is signed at. The signTime+// allows you to specify that a request is signed for the future, and cannot+// be used until then.+//+// Returns a list of HTTP headers that were included in the signature or an+// error if signing the request failed. For presigned requests these headers+// and their values must be included on the HTTP request when it is made. This+// is helpful to know what header values need to be shared with the party the+// presigned request will be distributed to.+//+// Presign differs from Sign in that it will sign the request using query string+// instead of header values. This allows you to share the Presigned Request's+// URL with third parties, or distribute it throughout your system with minimal+// dependencies.+//+// Presign also takes an exp value which is the duration the+// signed request will be valid after the signing time. This is allows you to+// set when the request will expire.+//+// The requests body is an io.ReadSeeker so the SHA256 of the body can be+// generated. To bypass the signer computing the hash you can set the+// "X-Amz-Content-Sha256" header with a precomputed value. The signer will+// only compute the hash if the request header value is empty.+//+// Presigning a S3 request will not compute the body's SHA256 hash by default.+// This is done due to the general use case for S3 presigned URLs is to share+// PUT/GET capabilities. If you would like to include the body's SHA256 in the+// presigned request's signature you can set the "X-Amz-Content-Sha256"+// HTTP header and that will be included in the request's signature.+func (v4 Signer) Presign(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, signTime time.Time) (http.Header, error) {+ return v4.signWithBody(r, body, service, region, exp, true, signTime)+}++func (v4 Signer) signWithBody(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, isPresign bool, signTime time.Time) (http.Header, error) {+ currentTimeFn := v4.currentTimeFn+ if currentTimeFn == nil {+ currentTimeFn = time.Now+ }++ ctx := &signingCtx{+ Request: r,+ Body: body,+ Query: r.URL.Query(),+ Time: signTime,+ ExpireTime: exp,+ isPresign: isPresign,+ ServiceName: service,+ Region: region,+ DisableURIPathEscaping: v4.DisableURIPathEscaping,+ unsignedPayload: v4.UnsignedPayload,+ }++ for key := range ctx.Query {+ sort.Strings(ctx.Query[key])+ }++ if ctx.isRequestSigned() {+ ctx.Time = currentTimeFn()+ ctx.handlePresignRemoval()+ }++ var err error+ ctx.credValues, err = v4.Credentials.Get()+ if err != nil {+ return http.Header{}, err+ }++ ctx.sanitizeHostForHeader()+ ctx.assignAmzQueryValues()+ if err := ctx.build(v4.DisableHeaderHoisting); err != nil {+ return nil, err+ }++ // If the request is not presigned the body should be attached to it. This+ // prevents the confusion of wanting to send a signed request without+ // the body the request was signed for attached.+ if !(v4.DisableRequestBodyOverwrite || ctx.isPresign) {+ var reader io.ReadCloser+ if body != nil {+ var ok bool+ if reader, ok = body.(io.ReadCloser); !ok {+ reader = ioutil.NopCloser(body)+ }+ }+ r.Body = reader+ }++ if v4.Debug.Matches(aws.LogDebugWithSigning) {+ v4.logSigningInfo(ctx)+ }++ return ctx.SignedHeaderVals, nil+}++func (ctx *signingCtx) sanitizeHostForHeader() {+ request.SanitizeHostForHeader(ctx.Request)+}++func (ctx *signingCtx) handlePresignRemoval() {+ if !ctx.isPresign {+ return+ }++ // The credentials have expired for this request. The current signing+ // is invalid, and needs to be request because the request will fail.+ ctx.removePresign()++ // Update the request's query string to ensure the values stays in+ // sync in the case retrieving the new credentials fails.+ ctx.Request.URL.RawQuery = ctx.Query.Encode()+}++func (ctx *signingCtx) assignAmzQueryValues() {+ if ctx.isPresign {+ ctx.Query.Set("X-Amz-Algorithm", authHeaderPrefix)+ if ctx.credValues.SessionToken != "" {+ ctx.Query.Set("X-Amz-Security-Token", ctx.credValues.SessionToken)+ } else {+ ctx.Query.Del("X-Amz-Security-Token")+ }++ return+ }++ if ctx.credValues.SessionToken != "" {+ ctx.Request.Header.Set("X-Amz-Security-Token", ctx.credValues.SessionToken)+ }+}++// SignRequestHandler is a named request handler the SDK will use to sign+// service client request with using the V4 signature.+var SignRequestHandler = request.NamedHandler{+ Name: "v4.SignRequestHandler", Fn: SignSDKRequest,+}++// SignSDKRequest signs an AWS request with the V4 signature. This+// request handler should only be used with the SDK's built in service client's+// API operation requests.+//+// This function should not be used on its on its own, but in conjunction with+// an AWS service client's API operation call. To sign a standalone request+// not created by a service client's API operation method use the "Sign" or+// "Presign" functions of the "Signer" type.+//+// If the credentials of the request's config are set to+// credentials.AnonymousCredentials the request will not be signed.+func SignSDKRequest(req *request.Request) {+ SignSDKRequestWithCurrentTime(req, time.Now)+}++// BuildNamedHandler will build a generic handler for signing.+func BuildNamedHandler(name string, opts ...func(*Signer)) request.NamedHandler {+ return request.NamedHandler{+ Name: name,+ Fn: func(req *request.Request) {+ SignSDKRequestWithCurrentTime(req, time.Now, opts...)+ },+ }+}++// SignSDKRequestWithCurrentTime will sign the SDK's request using the time+// function passed in. Behaves the same as SignSDKRequest with the exception+// the request is signed with the value returned by the current time function.+func SignSDKRequestWithCurrentTime(req *request.Request, curTimeFn func() time.Time, opts ...func(*Signer)) {+ // If the request does not need to be signed ignore the signing of the+ // request if the AnonymousCredentials object is used.+ if req.Config.Credentials == credentials.AnonymousCredentials {+ return+ }++ region := req.ClientInfo.SigningRegion+ if region == "" {+ region = aws.StringValue(req.Config.Region)+ }++ name := req.ClientInfo.SigningName+ if name == "" {+ name = req.ClientInfo.ServiceName+ }++ v4 := NewSigner(req.Config.Credentials, func(v4 *Signer) {+ v4.Debug = req.Config.LogLevel.Value()+ v4.Logger = req.Config.Logger+ v4.DisableHeaderHoisting = req.NotHoist+ v4.currentTimeFn = curTimeFn+ if name == "s3" {+ // S3 service should not have any escaping applied+ v4.DisableURIPathEscaping = true+ }+ // Prevents setting the HTTPRequest's Body. Since the Body could be+ // wrapped in a custom io.Closer that we do not want to be stompped+ // on top of by the signer.+ v4.DisableRequestBodyOverwrite = true+ })++ for _, opt := range opts {+ opt(v4)+ }++ curTime := curTimeFn()+ signedHeaders, err := v4.signWithBody(req.HTTPRequest, req.GetBody(),+ name, region, req.ExpireTime, req.ExpireTime > 0, curTime,+ )+ if err != nil {+ req.Error = err+ req.SignedHeaderVals = nil+ return+ }++ req.SignedHeaderVals = signedHeaders+ req.LastSignedAt = curTime+}++const logSignInfoMsg = `DEBUG: Request Signature:+---[ CANONICAL STRING ]-----------------------------+%s+---[ STRING TO SIGN ]--------------------------------+%s%s+-----------------------------------------------------`+const logSignedURLMsg = `+---[ SIGNED URL ]------------------------------------+%s`++func (v4 *Signer) logSigningInfo(ctx *signingCtx) {+ signedURLMsg := ""+ if ctx.isPresign {+ signedURLMsg = fmt.Sprintf(logSignedURLMsg, ctx.Request.URL.String())+ }+ msg := fmt.Sprintf(logSignInfoMsg, ctx.canonicalString, ctx.stringToSign, signedURLMsg)+ v4.Logger.Log(msg)+}++func (ctx *signingCtx) build(disableHeaderHoisting bool) error {+ ctx.buildTime() // no depends+ ctx.buildCredentialString() // no depends++ if err := ctx.buildBodyDigest(); err != nil {+ return err+ }++ unsignedHeaders := ctx.Request.Header+ if ctx.isPresign {+ if !disableHeaderHoisting {+ urlValues := url.Values{}+ urlValues, unsignedHeaders = buildQuery(allowedQueryHoisting, unsignedHeaders) // no depends+ for k := range urlValues {+ ctx.Query[k] = urlValues[k]+ }+ }+ }++ ctx.buildCanonicalHeaders(ignoredHeaders, unsignedHeaders)+ ctx.buildCanonicalString() // depends on canon headers / signed headers+ ctx.buildStringToSign() // depends on canon string+ ctx.buildSignature() // depends on string to sign++ if ctx.isPresign {+ ctx.Request.URL.RawQuery += "&X-Amz-Signature=" + ctx.signature+ } else {+ parts := []string{+ authHeaderPrefix + " Credential=" + ctx.credValues.AccessKeyID + "/" + ctx.credentialString,+ "SignedHeaders=" + ctx.signedHeaders,+ "Signature=" + ctx.signature,+ }+ ctx.Request.Header.Set("Authorization", strings.Join(parts, ", "))+ }++ return nil+}++func (ctx *signingCtx) buildTime() {+ ctx.formattedTime = ctx.Time.UTC().Format(timeFormat)+ ctx.formattedShortTime = ctx.Time.UTC().Format(shortTimeFormat)++ if ctx.isPresign {+ duration := int64(ctx.ExpireTime / time.Second)+ ctx.Query.Set("X-Amz-Date", ctx.formattedTime)+ ctx.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))+ } else {+ ctx.Request.Header.Set("X-Amz-Date", ctx.formattedTime)+ }+}++func (ctx *signingCtx) buildCredentialString() {+ ctx.credentialString = strings.Join([]string{+ ctx.formattedShortTime,+ ctx.Region,+ ctx.ServiceName,+ "aws4_request",+ }, "/")++ if ctx.isPresign {+ ctx.Query.Set("X-Amz-Credential", ctx.credValues.AccessKeyID+"/"+ctx.credentialString)+ }+}++func buildQuery(r rule, header http.Header) (url.Values, http.Header) {+ query := url.Values{}+ unsignedHeaders := http.Header{}+ for k, h := range header {+ if r.IsValid(k) {+ query[k] = h+ } else {+ unsignedHeaders[k] = h+ }+ }++ return query, unsignedHeaders+}+func (ctx *signingCtx) buildCanonicalHeaders(r rule, header http.Header) {+ var headers []string+ headers = append(headers, "host")+ for k, v := range header {+ canonicalKey := http.CanonicalHeaderKey(k)+ if !r.IsValid(canonicalKey) {+ continue // ignored header+ }+ if ctx.SignedHeaderVals == nil {+ ctx.SignedHeaderVals = make(http.Header)+ }++ lowerCaseKey := strings.ToLower(k)+ if _, ok := ctx.SignedHeaderVals[lowerCaseKey]; ok {+ // include additional values+ ctx.SignedHeaderVals[lowerCaseKey] = append(ctx.SignedHeaderVals[lowerCaseKey], v...)+ continue+ }++ headers = append(headers, lowerCaseKey)+ ctx.SignedHeaderVals[lowerCaseKey] = v+ }+ sort.Strings(headers)++ ctx.signedHeaders = strings.Join(headers, ";")++ if ctx.isPresign {+ ctx.Query.Set("X-Amz-SignedHeaders", ctx.signedHeaders)+ }++ headerValues := make([]string, len(headers))+ for i, k := range headers {+ if k == "host" {+ if ctx.Request.Host != "" {+ headerValues[i] = "host:" + ctx.Request.Host+ } else {+ headerValues[i] = "host:" + ctx.Request.URL.Host+ }+ } else {+ headerValues[i] = k + ":" ++ strings.Join(ctx.SignedHeaderVals[k], ",")+ }+ }+ stripExcessSpaces(headerValues)+ ctx.canonicalHeaders = strings.Join(headerValues, "\n")+}++func (ctx *signingCtx) buildCanonicalString() {+ ctx.Request.URL.RawQuery = strings.Replace(ctx.Query.Encode(), "+", "%20", -1)++ uri := getURIPath(ctx.Request.URL)++ if !ctx.DisableURIPathEscaping {+ uri = rest.EscapePath(uri, false)+ }++ ctx.canonicalString = strings.Join([]string{+ ctx.Request.Method,+ uri,+ ctx.Request.URL.RawQuery,+ ctx.canonicalHeaders + "\n",+ ctx.signedHeaders,+ ctx.bodyDigest,+ }, "\n")+}++func (ctx *signingCtx) buildStringToSign() {+ ctx.stringToSign = strings.Join([]string{+ authHeaderPrefix,+ ctx.formattedTime,+ ctx.credentialString,+ hex.EncodeToString(makeSha256([]byte(ctx.canonicalString))),+ }, "\n")+}++func (ctx *signingCtx) buildSignature() {+ secret := ctx.credValues.SecretAccessKey+ date := makeHmac([]byte("AWS4"+secret), []byte(ctx.formattedShortTime))+ region := makeHmac(date, []byte(ctx.Region))+ service := makeHmac(region, []byte(ctx.ServiceName))+ credentials := makeHmac(service, []byte("aws4_request"))+ signature := makeHmac(credentials, []byte(ctx.stringToSign))+ ctx.signature = hex.EncodeToString(signature)+}++func (ctx *signingCtx) buildBodyDigest() error {+ hash := ctx.Request.Header.Get("X-Amz-Content-Sha256")+ if hash == "" {+ includeSHA256Header := ctx.unsignedPayload ||+ ctx.ServiceName == "s3" ||+ ctx.ServiceName == "glacier"++ s3Presign := ctx.isPresign && ctx.ServiceName == "s3"++ if ctx.unsignedPayload || s3Presign {+ hash = "UNSIGNED-PAYLOAD"+ includeSHA256Header = !s3Presign+ } else if ctx.Body == nil {+ hash = emptyStringSHA256+ } else {+ if !aws.IsReaderSeekable(ctx.Body) {+ return fmt.Errorf("cannot use unseekable request body %T, for signed request with body", ctx.Body)+ }+ hash = hex.EncodeToString(makeSha256Reader(ctx.Body))+ }++ if includeSHA256Header {+ ctx.Request.Header.Set("X-Amz-Content-Sha256", hash)+ }+ }+ ctx.bodyDigest = hash++ return nil+}++// isRequestSigned returns if the request is currently signed or presigned+func (ctx *signingCtx) isRequestSigned() bool {+ if ctx.isPresign && ctx.Query.Get("X-Amz-Signature") != "" {+ return true+ }+ if ctx.Request.Header.Get("Authorization") != "" {+ return true+ }++ return false+}++// unsign removes signing flags for both signed and presigned requests.+func (ctx *signingCtx) removePresign() {+ ctx.Query.Del("X-Amz-Algorithm")+ ctx.Query.Del("X-Amz-Signature")+ ctx.Query.Del("X-Amz-Security-Token")+ ctx.Query.Del("X-Amz-Date")+ ctx.Query.Del("X-Amz-Expires")+ ctx.Query.Del("X-Amz-Credential")+ ctx.Query.Del("X-Amz-SignedHeaders")+}++func makeHmac(key []byte, data []byte) []byte {+ hash := hmac.New(sha256.New, key)+ hash.Write(data)+ return hash.Sum(nil)+}++func makeSha256(data []byte) []byte {+ hash := sha256.New()+ hash.Write(data)+ return hash.Sum(nil)+}++func makeSha256Reader(reader io.ReadSeeker) []byte {+ hash := sha256.New()+ start, _ := reader.Seek(0, sdkio.SeekCurrent)+ defer reader.Seek(start, sdkio.SeekStart)++ // Use CopyN to avoid allocating the 32KB buffer in io.Copy for bodies+ // smaller than 32KB. Fall back to io.Copy if we fail to determine the size.+ size, err := aws.SeekerLen(reader)+ if err != nil {+ io.Copy(hash, reader)+ } else {+ io.CopyN(hash, reader, size)+ }++ return hash.Sum(nil)+}++const doubleSpace = " "++// stripExcessSpaces will rewrite the passed in slice's string values to not+// contain muliple side-by-side spaces.+func stripExcessSpaces(vals []string) {+ var j, k, l, m, spaces int+ for i, str := range vals {+ // Trim trailing spaces+ for j = len(str) - 1; j >= 0 && str[j] == ' '; j-- {+ }++ // Trim leading spaces+ for k = 0; k < j && str[k] == ' '; k++ {+ }+ str = str[k : j+1]++ // Strip multiple spaces.+ j = strings.Index(str, doubleSpace)+ if j < 0 {+ vals[i] = str+ continue+ }++ buf := []byte(str)+ for k, m, l = j, j, len(buf); k < l; k++ {+ if buf[k] == ' ' {+ if spaces == 0 {+ // First space.+ buf[m] = buf[k]+ m+++ }+ spaces+++ } else {+ // End of multiple spaces.+ spaces = 0+ buf[m] = buf[k]+ m+++ }+ }++ vals[i] = string(buf[:m])+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/types.go b/vendor/github.com/aws/aws-sdk-go/aws/types.gonew file mode 100644index 000000000..8b6f23425--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/types.go@@ -0,0 +1,201 @@+package aws++import (+ "io"+ "sync"++ "github.com/aws/aws-sdk-go/internal/sdkio"+)++// ReadSeekCloser wraps a io.Reader returning a ReaderSeekerCloser. Should+// only be used with an io.Reader that is also an io.Seeker. Doing so may+// cause request signature errors, or request body's not sent for GET, HEAD+// and DELETE HTTP methods.+//+// Deprecated: Should only be used with io.ReadSeeker. If using for+// S3 PutObject to stream content use s3manager.Uploader instead.+func ReadSeekCloser(r io.Reader) ReaderSeekerCloser {+ return ReaderSeekerCloser{r}+}++// ReaderSeekerCloser represents a reader that can also delegate io.Seeker and+// io.Closer interfaces to the underlying object if they are available.+type ReaderSeekerCloser struct {+ r io.Reader+}++// IsReaderSeekable returns if the underlying reader type can be seeked. A+// io.Reader might not actually be seekable if it is the ReaderSeekerCloser+// type.+func IsReaderSeekable(r io.Reader) bool {+ switch v := r.(type) {+ case ReaderSeekerCloser:+ return v.IsSeeker()+ case *ReaderSeekerCloser:+ return v.IsSeeker()+ case io.ReadSeeker:+ return true+ default:+ return false+ }+}++// Read reads from the reader up to size of p. The number of bytes read, and+// error if it occurred will be returned.+//+// If the reader is not an io.Reader zero bytes read, and nil error will be returned.+//+// Performs the same functionality as io.Reader Read+func (r ReaderSeekerCloser) Read(p []byte) (int, error) {+ switch t := r.r.(type) {+ case io.Reader:+ return t.Read(p)+ }+ return 0, nil+}++// Seek sets the offset for the next Read to offset, interpreted according to+// whence: 0 means relative to the origin of the file, 1 means relative to the+// current offset, and 2 means relative to the end. Seek returns the new offset+// and an error, if any.+//+// If the ReaderSeekerCloser is not an io.Seeker nothing will be done.+func (r ReaderSeekerCloser) Seek(offset int64, whence int) (int64, error) {+ switch t := r.r.(type) {+ case io.Seeker:+ return t.Seek(offset, whence)+ }+ return int64(0), nil+}++// IsSeeker returns if the underlying reader is also a seeker.+func (r ReaderSeekerCloser) IsSeeker() bool {+ _, ok := r.r.(io.Seeker)+ return ok+}++// HasLen returns the length of the underlying reader if the value implements+// the Len() int method.+func (r ReaderSeekerCloser) HasLen() (int, bool) {+ type lenner interface {+ Len() int+ }++ if lr, ok := r.r.(lenner); ok {+ return lr.Len(), true+ }++ return 0, false+}++// GetLen returns the length of the bytes remaining in the underlying reader.+// Checks first for Len(), then io.Seeker to determine the size of the+// underlying reader.+//+// Will return -1 if the length cannot be determined.+func (r ReaderSeekerCloser) GetLen() (int64, error) {+ if l, ok := r.HasLen(); ok {+ return int64(l), nil+ }++ if s, ok := r.r.(io.Seeker); ok {+ return seekerLen(s)+ }++ return -1, nil+}++// SeekerLen attempts to get the number of bytes remaining at the seeker's+// current position. Returns the number of bytes remaining or error.+func SeekerLen(s io.Seeker) (int64, error) {+ // Determine if the seeker is actually seekable. ReaderSeekerCloser+ // hides the fact that a io.Readers might not actually be seekable.+ switch v := s.(type) {+ case ReaderSeekerCloser:+ return v.GetLen()+ case *ReaderSeekerCloser:+ return v.GetLen()+ }++ return seekerLen(s)+}++func seekerLen(s io.Seeker) (int64, error) {+ curOffset, err := s.Seek(0, sdkio.SeekCurrent)+ if err != nil {+ return 0, err+ }++ endOffset, err := s.Seek(0, sdkio.SeekEnd)+ if err != nil {+ return 0, err+ }++ _, err = s.Seek(curOffset, sdkio.SeekStart)+ if err != nil {+ return 0, err+ }++ return endOffset - curOffset, nil+}++// Close closes the ReaderSeekerCloser.+//+// If the ReaderSeekerCloser is not an io.Closer nothing will be done.+func (r ReaderSeekerCloser) Close() error {+ switch t := r.r.(type) {+ case io.Closer:+ return t.Close()+ }+ return nil+}++// A WriteAtBuffer provides a in memory buffer supporting the io.WriterAt interface+// Can be used with the s3manager.Downloader to download content to a buffer+// in memory. Safe to use concurrently.+type WriteAtBuffer struct {+ buf []byte+ m sync.Mutex++ // GrowthCoeff defines the growth rate of the internal buffer. By+ // default, the growth rate is 1, where expanding the internal+ // buffer will allocate only enough capacity to fit the new expected+ // length.+ GrowthCoeff float64+}++// NewWriteAtBuffer creates a WriteAtBuffer with an internal buffer+// provided by buf.+func NewWriteAtBuffer(buf []byte) *WriteAtBuffer {+ return &WriteAtBuffer{buf: buf}+}++// WriteAt writes a slice of bytes to a buffer starting at the position provided+// The number of bytes written will be returned, or error. Can overwrite previous+// written slices if the write ats overlap.+func (b *WriteAtBuffer) WriteAt(p []byte, pos int64) (n int, err error) {+ pLen := len(p)+ expLen := pos + int64(pLen)+ b.m.Lock()+ defer b.m.Unlock()+ if int64(len(b.buf)) < expLen {+ if int64(cap(b.buf)) < expLen {+ if b.GrowthCoeff < 1 {+ b.GrowthCoeff = 1+ }+ newBuf := make([]byte, expLen, int64(b.GrowthCoeff*float64(expLen)))+ copy(newBuf, b.buf)+ b.buf = newBuf+ }+ b.buf = b.buf[:expLen]+ }+ copy(b.buf[pos:], p)+ return pLen, nil+}++// Bytes returns a slice of bytes written to the buffer.+func (b *WriteAtBuffer) Bytes() []byte {+ b.m.Lock()+ defer b.m.Unlock()+ return b.buf+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/url.go b/vendor/github.com/aws/aws-sdk-go/aws/url.gonew file mode 100644index 000000000..6192b2455--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/url.go@@ -0,0 +1,12 @@+// +build go1.8++package aws++import "net/url"++// URLHostname will extract the Hostname without port from the URL value.+//+// Wrapper of net/url#URL.Hostname for backwards Go version compatibility.+func URLHostname(url *url.URL) string {+ return url.Hostname()+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.gonew file mode 100644index 000000000..0210d2720--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go@@ -0,0 +1,29 @@+// +build !go1.8++package aws++import (+ "net/url"+ "strings"+)++// URLHostname will extract the Hostname without port from the URL value.+//+// Copy of Go 1.8's net/url#URL.Hostname functionality.+func URLHostname(url *url.URL) string {+ return stripPort(url.Host)++}++// stripPort is copy of Go 1.8 url#URL.Hostname functionality.+// https://golang.org/src/net/url/url.go+func stripPort(hostport string) string {+ colon := strings.IndexByte(hostport, ':')+ if colon == -1 {+ return hostport+ }+ if i := strings.IndexByte(hostport, ']'); i != -1 {+ return strings.TrimPrefix(hostport[:i], "[")+ }+ return hostport[:colon]+}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/version.go b/vendor/github.com/aws/aws-sdk-go/aws/version.gonew file mode 100644index 000000000..8ab57837b--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/aws/version.go@@ -0,0 +1,8 @@+// Package aws provides core functionality for making requests to AWS services.+package aws++// SDKName is the name of this AWS SDK+const SDKName = "aws-sdk-go"++// SDKVersion is the version of this SDK+const SDKVersion = "1.16.3"diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/ast.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/ast.gonew file mode 100644index 000000000..e83a99886--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/ast.go@@ -0,0 +1,120 @@+package ini++// ASTKind represents different states in the parse table+// and the type of AST that is being constructed+type ASTKind int++// ASTKind* is used in the parse table to transition between+// the different states+const (+ ASTKindNone = ASTKind(iota)+ ASTKindStart+ ASTKindExpr+ ASTKindEqualExpr+ ASTKindStatement+ ASTKindSkipStatement+ ASTKindExprStatement+ ASTKindSectionStatement+ ASTKindNestedSectionStatement+ ASTKindCompletedNestedSectionStatement+ ASTKindCommentStatement+ ASTKindCompletedSectionStatement+)++func (k ASTKind) String() string {+ switch k {+ case ASTKindNone:+ return "none"+ case ASTKindStart:+ return "start"+ case ASTKindExpr:+ return "expr"+ case ASTKindStatement:+ return "stmt"+ case ASTKindSectionStatement:+ return "section_stmt"+ case ASTKindExprStatement:+ return "expr_stmt"+ case ASTKindCommentStatement:+ return "comment"+ case ASTKindNestedSectionStatement:+ return "nested_section_stmt"+ case ASTKindCompletedSectionStatement:+ return "completed_stmt"+ case ASTKindSkipStatement:+ return "skip"+ default:+ return ""+ }+}++// AST interface allows us to determine what kind of node we+// are on and casting may not need to be necessary.+//+// The root is always the first node in Children+type AST struct {+ Kind ASTKind+ Root Token+ RootToken bool+ Children []AST+}++func newAST(kind ASTKind, root AST, children ...AST) AST {+ return AST{+ Kind: kind,+ Children: append([]AST{root}, children...),+ }+}++func newASTWithRootToken(kind ASTKind, root Token, children ...AST) AST {+ return AST{+ Kind: kind,+ Root: root,+ RootToken: true,+ Children: children,+ }+}++// AppendChild will append to the list of children an AST has.+func (a *AST) AppendChild(child AST) {+ a.Children = append(a.Children, child)+}++// GetRoot will return the root AST which can be the first entry+// in the children list or a token.+func (a *AST) GetRoot() AST {+ if a.RootToken {+ return *a+ }++ if len(a.Children) == 0 {+ return AST{}+ }++ return a.Children[0]+}++// GetChildren will return the current AST's list of children+func (a *AST) GetChildren() []AST {+ if len(a.Children) == 0 {+ return []AST{}+ }++ if a.RootToken {+ return a.Children+ }++ return a.Children[1:]+}++// SetChildren will set and override all children of the AST.+func (a *AST) SetChildren(children []AST) {+ if a.RootToken {+ a.Children = children+ } else {+ a.Children = append(a.Children[:1], children...)+ }+}++// Start is used to indicate the starting state of the parse table.+var Start = newAST(ASTKindStart, AST{})diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/comma_token.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/comma_token.gonew file mode 100644index 000000000..0895d53cb--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/comma_token.go@@ -0,0 +1,11 @@+package ini++var commaRunes = []rune(",")++func isComma(b rune) bool {+ return b == ','+}++func newCommaToken() Token {+ return newToken(TokenComma, commaRunes, NoneType)+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/comment_token.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/comment_token.gonew file mode 100644index 000000000..0b76999ba--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/comment_token.go@@ -0,0 +1,35 @@+package ini++// isComment will return whether or not the next byte(s) is a+// comment.+func isComment(b []rune) bool {+ if len(b) == 0 {+ return false+ }++ switch b[0] {+ case ';':+ return true+ case '#':+ return true+ }++ return false+}++// newCommentToken will create a comment token and+// return how many bytes were read.+func newCommentToken(b []rune) (Token, int, error) {+ i := 0+ for ; i < len(b); i++ {+ if b[i] == '\n' {+ break+ }++ if len(b)-i > 2 && b[i] == '\r' && b[i+1] == '\n' {+ break+ }+ }++ return newToken(TokenComment, b[:i], NoneType), i, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/doc.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/doc.gonew file mode 100644index 000000000..25ce0fe13--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/doc.go@@ -0,0 +1,29 @@+// Package ini is an LL(1) parser for configuration files.+//+// Example:+// sections, err := ini.OpenFile("/path/to/file")+// if err != nil {+// panic(err)+// }+//+// profile := "foo"+// section, ok := sections.GetSection(profile)+// if !ok {+// fmt.Printf("section %q could not be found", profile)+// }+//+// Below is the BNF that describes this parser+// Grammar:+// stmt -> value stmt'+// stmt' -> epsilon | op stmt+// value -> number | string | boolean | quoted_string+//+// section -> [ section'+// section' -> value section_close+// section_close -> ]+//+// SkipState will skip (NL WS)++//+// comment -> # comment' | ; comment'+// comment' -> epsilon | value+package inidiff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/empty_token.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/empty_token.gonew file mode 100644index 000000000..04345a54c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/empty_token.go@@ -0,0 +1,4 @@+package ini++// emptyToken is used to satisfy the Token interface+var emptyToken = newToken(TokenNone, []rune{}, NoneType)diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/expression.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/expression.gonew file mode 100644index 000000000..91ba2a59d--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/expression.go@@ -0,0 +1,24 @@+package ini++// newExpression will return an expression AST.+// Expr represents an expression+//+// grammar:+// expr -> string | number+func newExpression(tok Token) AST {+ return newASTWithRootToken(ASTKindExpr, tok)+}++func newEqualExpr(left AST, tok Token) AST {+ return newASTWithRootToken(ASTKindEqualExpr, tok, left)+}++// EqualExprKey will return a LHS value in the equal expr+func EqualExprKey(ast AST) string {+ children := ast.GetChildren()+ if len(children) == 0 || ast.Kind != ASTKindEqualExpr {+ return ""+ }++ return string(children[0].Root.Raw())+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/fuzz.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/fuzz.gonew file mode 100644index 000000000..8d462f77e--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/fuzz.go@@ -0,0 +1,17 @@+// +build gofuzz++package ini++import (+ "bytes"+)++func Fuzz(data []byte) int {+ b := bytes.NewReader(data)++ if _, err := Parse(b); err != nil {+ return 0+ }++ return 1+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/ini.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini.gonew file mode 100644index 000000000..3b0ca7afe--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini.go@@ -0,0 +1,51 @@+package ini++import (+ "io"+ "os"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++// OpenFile takes a path to a given file, and will open and parse+// that file.+func OpenFile(path string) (Sections, error) {+ f, err := os.Open(path)+ if err != nil {+ return Sections{}, awserr.New(ErrCodeUnableToReadFile, "unable to open file", err)+ }+ defer f.Close()++ return Parse(f)+}++// Parse will parse the given file using the shared config+// visitor.+func Parse(f io.Reader) (Sections, error) {+ tree, err := ParseAST(f)+ if err != nil {+ return Sections{}, err+ }++ v := NewDefaultVisitor()+ if err = Walk(tree, v); err != nil {+ return Sections{}, err+ }++ return v.Sections, nil+}++// ParseBytes will parse the given bytes and return the parsed sections.+func ParseBytes(b []byte) (Sections, error) {+ tree, err := ParseASTBytes(b)+ if err != nil {+ return Sections{}, err+ }++ v := NewDefaultVisitor()+ if err = Walk(tree, v); err != nil {+ return Sections{}, err+ }++ return v.Sections, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_lexer.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_lexer.gonew file mode 100644index 000000000..582c024ad--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_lexer.go@@ -0,0 +1,165 @@+package ini++import (+ "bytes"+ "io"+ "io/ioutil"++ "github.com/aws/aws-sdk-go/aws/awserr"+)++const (+ // ErrCodeUnableToReadFile is used when a file is failed to be+ // opened or read from.+ ErrCodeUnableToReadFile = "FailedRead"+)++// TokenType represents the various different tokens types+type TokenType int++func (t TokenType) String() string {+ switch t {+ case TokenNone:+ return "none"+ case TokenLit:+ return "literal"+ case TokenSep:+ return "sep"+ case TokenOp:+ return "op"+ case TokenWS:+ return "ws"+ case TokenNL:+ return "newline"+ case TokenComment:+ return "comment"+ case TokenComma:+ return "comma"+ default:+ return ""+ }+}++// TokenType enums+const (+ TokenNone = TokenType(iota)+ TokenLit+ TokenSep+ TokenComma+ TokenOp+ TokenWS+ TokenNL+ TokenComment+)++type iniLexer struct{}++// Tokenize will return a list of tokens during lexical analysis of the+// io.Reader.+func (l *iniLexer) Tokenize(r io.Reader) ([]Token, error) {+ b, err := ioutil.ReadAll(r)+ if err != nil {+ return nil, awserr.New(ErrCodeUnableToReadFile, "unable to read file", err)+ }++ return l.tokenize(b)+}++func (l *iniLexer) tokenize(b []byte) ([]Token, error) {+ runes := bytes.Runes(b)+ var err error+ n := 0+ tokenAmount := countTokens(runes)+ tokens := make([]Token, tokenAmount)+ count := 0++ for len(runes) > 0 && count < tokenAmount {+ switch {+ case isWhitespace(runes[0]):+ tokens[count], n, err = newWSToken(runes)+ case isComma(runes[0]):+ tokens[count], n = newCommaToken(), 1+ case isComment(runes):+ tokens[count], n, err = newCommentToken(runes)+ case isNewline(runes):+ tokens[count], n, err = newNewlineToken(runes)+ case isSep(runes):+ tokens[count], n, err = newSepToken(runes)+ case isOp(runes):+ tokens[count], n, err = newOpToken(runes)+ default:+ tokens[count], n, err = newLitToken(runes)+ }++ if err != nil {+ return nil, err+ }++ count++++ runes = runes[n:]+ }++ return tokens[:count], nil+}++func countTokens(runes []rune) int {+ count, n := 0, 0+ var err error++ for len(runes) > 0 {+ switch {+ case isWhitespace(runes[0]):+ _, n, err = newWSToken(runes)+ case isComma(runes[0]):+ _, n = newCommaToken(), 1+ case isComment(runes):+ _, n, err = newCommentToken(runes)+ case isNewline(runes):+ _, n, err = newNewlineToken(runes)+ case isSep(runes):+ _, n, err = newSepToken(runes)+ case isOp(runes):+ _, n, err = newOpToken(runes)+ default:+ _, n, err = newLitToken(runes)+ }++ if err != nil {+ return 0+ }++ count+++ runes = runes[n:]+ }++ return count + 1+}++// Token indicates a metadata about a given value.+type Token struct {+ t TokenType+ ValueType ValueType+ base int+ raw []rune+}++var emptyValue = Value{}++func newToken(t TokenType, raw []rune, v ValueType) Token {+ return Token{+ t: t,+ raw: raw,+ ValueType: v,+ }+}++// Raw return the raw runes that were consumed+func (tok Token) Raw() []rune {+ return tok.raw+}++// Type returns the token type+func (tok Token) Type() TokenType {+ return tok.t+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_parser.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_parser.gonew file mode 100644index 000000000..8be520ae6--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/ini_parser.go@@ -0,0 +1,347 @@+package ini++import (+ "fmt"+ "io"+)++// State enums for the parse table+const (+ InvalidState = iota+ // stmt -> value stmt'+ StatementState+ // stmt' -> MarkComplete | op stmt+ StatementPrimeState+ // value -> number | string | boolean | quoted_string+ ValueState+ // section -> [ section'+ OpenScopeState+ // section' -> value section_close+ SectionState+ // section_close -> ]+ CloseScopeState+ // SkipState will skip (NL WS)++ SkipState+ // SkipTokenState will skip any token and push the previous+ // state onto the stack.+ SkipTokenState+ // comment -> # comment' | ; comment'+ // comment' -> MarkComplete | value+ CommentState+ // MarkComplete state will complete statements and move that+ // to the completed AST list+ MarkCompleteState+ // TerminalState signifies that the tokens have been fully parsed+ TerminalState+)++// parseTable is a state machine to dictate the grammar above.+var parseTable = map[ASTKind]map[TokenType]int{+ ASTKindStart: map[TokenType]int{+ TokenLit: StatementState,+ TokenSep: OpenScopeState,+ TokenWS: SkipTokenState,+ TokenNL: SkipTokenState,+ TokenComment: CommentState,+ TokenNone: TerminalState,+ },+ ASTKindCommentStatement: map[TokenType]int{+ TokenLit: StatementState,+ TokenSep: OpenScopeState,+ TokenWS: SkipTokenState,+ TokenNL: SkipTokenState,+ TokenComment: CommentState,+ TokenNone: MarkCompleteState,+ },+ ASTKindExpr: map[TokenType]int{+ TokenOp: StatementPrimeState,+ TokenLit: ValueState,+ TokenSep: OpenScopeState,+ TokenWS: ValueState,+ TokenNL: SkipState,+ TokenComment: CommentState,+ TokenNone: MarkCompleteState,+ },+ ASTKindEqualExpr: map[TokenType]int{+ TokenLit: ValueState,+ TokenWS: SkipTokenState,+ TokenNL: SkipState,+ },+ ASTKindStatement: map[TokenType]int{+ TokenLit: SectionState,+ TokenSep: CloseScopeState,+ TokenWS: SkipTokenState,+ TokenNL: SkipTokenState,+ TokenComment: CommentState,+ TokenNone: MarkCompleteState,+ },+ ASTKindExprStatement: map[TokenType]int{+ TokenLit: ValueState,+ TokenSep: OpenScopeState,+ TokenOp: ValueState,+ TokenWS: ValueState,+ TokenNL: MarkCompleteState,+ TokenComment: CommentState,+ TokenNone: TerminalState,+ TokenComma: SkipState,+ },+ ASTKindSectionStatement: map[TokenType]int{+ TokenLit: SectionState,+ TokenOp: SectionState,+ TokenSep: CloseScopeState,+ TokenWS: SectionState,+ TokenNL: SkipTokenState,+ },+ ASTKindCompletedSectionStatement: map[TokenType]int{+ TokenWS: SkipTokenState,+ TokenNL: SkipTokenState,+ TokenLit: StatementState,+ TokenSep: OpenScopeState,+ TokenComment: CommentState,+ TokenNone: MarkCompleteState,+ },+ ASTKindSkipStatement: map[TokenType]int{+ TokenLit: StatementState,+ TokenSep: OpenScopeState,+ TokenWS: SkipTokenState,+ TokenNL: SkipTokenState,+ TokenComment: CommentState,+ TokenNone: TerminalState,+ },+}++// ParseAST will parse input from an io.Reader using+// an LL(1) parser.+func ParseAST(r io.Reader) ([]AST, error) {+ lexer := iniLexer{}+ tokens, err := lexer.Tokenize(r)+ if err != nil {+ return []AST{}, err+ }++ return parse(tokens)+}++// ParseASTBytes will parse input from a byte slice using+// an LL(1) parser.+func ParseASTBytes(b []byte) ([]AST, error) {+ lexer := iniLexer{}+ tokens, err := lexer.tokenize(b)+ if err != nil {+ return []AST{}, err+ }++ return parse(tokens)+}++func parse(tokens []Token) ([]AST, error) {+ start := Start+ stack := newParseStack(3, len(tokens))++ stack.Push(start)+ s := newSkipper()++loop:+ for stack.Len() > 0 {+ k := stack.Pop()++ var tok Token+ if len(tokens) == 0 {+ // this occurs when all the tokens have been processed+ // but reduction of what's left on the stack needs to+ // occur.+ tok = emptyToken+ } else {+ tok = tokens[0]+ }++ step := parseTable[k.Kind][tok.Type()]+ if s.ShouldSkip(tok) {+ // being in a skip state with no tokens will break out of+ // the parse loop since there is nothing left to process.+ if len(tokens) == 0 {+ break loop+ }++ step = SkipTokenState+ }++ switch step {+ case TerminalState:+ // Finished parsing. Push what should be the last+ // statement to the stack. If there is anything left+ // on the stack, an error in parsing has occurred.+ if k.Kind != ASTKindStart {+ stack.MarkComplete(k)+ }+ break loop+ case SkipTokenState:+ // When skipping a token, the previous state was popped off the stack.+ // To maintain the correct state, the previous state will be pushed+ // onto the stack.+ stack.Push(k)+ case StatementState:+ if k.Kind != ASTKindStart {+ stack.MarkComplete(k)+ }+ expr := newExpression(tok)+ stack.Push(expr)+ case StatementPrimeState:+ if tok.Type() != TokenOp {+ stack.MarkComplete(k)+ continue+ }++ if k.Kind != ASTKindExpr {+ return nil, NewParseError(+ fmt.Sprintf("invalid expression: expected Expr type, but found %T type", k),+ )+ }++ k = trimSpaces(k)+ expr := newEqualExpr(k, tok)+ stack.Push(expr)+ case ValueState:+ // ValueState requires the previous state to either be an equal expression+ // or an expression statement.+ //+ // This grammar occurs when the RHS is a number, word, or quoted string.+ // equal_expr -> lit op equal_expr'+ // equal_expr' -> number | string | quoted_string+ // quoted_string -> " quoted_string'+ // quoted_string' -> string quoted_string_end+ // quoted_string_end -> "+ //+ // otherwise+ // expr_stmt -> equal_expr (expr_stmt')*+ // expr_stmt' -> ws S | op S | MarkComplete+ // S -> equal_expr' expr_stmt'+ switch k.Kind {+ case ASTKindEqualExpr:+ // assiging a value to some key+ k.AppendChild(newExpression(tok))+ stack.Push(newExprStatement(k))+ case ASTKindExpr:+ k.Root.raw = append(k.Root.raw, tok.Raw()...)+ stack.Push(k)+ case ASTKindExprStatement:+ root := k.GetRoot()+ children := root.GetChildren()+ if len(children) == 0 {+ return nil, NewParseError(+ fmt.Sprintf("invalid expression: AST contains no children %s", k.Kind),+ )+ }++ rhs := children[len(children)-1]++ if rhs.Root.ValueType != QuotedStringType {+ rhs.Root.ValueType = StringType+ rhs.Root.raw = append(rhs.Root.raw, tok.Raw()...)++ }++ children[len(children)-1] = rhs+ k.SetChildren(children)++ stack.Push(k)+ }+ case OpenScopeState:+ if !runeCompare(tok.Raw(), openBrace) {+ return nil, NewParseError("expected '['")+ }++ stmt := newStatement()+ stack.Push(stmt)+ case CloseScopeState:+ if !runeCompare(tok.Raw(), closeBrace) {+ return nil, NewParseError("expected ']'")+ }++ k = trimSpaces(k)+ stack.Push(newCompletedSectionStatement(k))+ case SectionState:+ var stmt AST++ switch k.Kind {+ case ASTKindStatement:+ // If there are multiple literals inside of a scope declaration,+ // then the current token's raw value will be appended to the Name.+ //+ // This handles cases like [ profile default ]+ //+ // k will represent a SectionStatement with the children representing+ // the label of the section+ stmt = newSectionStatement(tok)+ case ASTKindSectionStatement:+ k.Root.raw = append(k.Root.raw, tok.Raw()...)+ stmt = k+ default:+ return nil, NewParseError(+ fmt.Sprintf("invalid statement: expected statement: %v", k.Kind),+ )+ }++ stack.Push(stmt)+ case MarkCompleteState:+ if k.Kind != ASTKindStart {+ stack.MarkComplete(k)+ }++ if stack.Len() == 0 {+ stack.Push(start)+ }+ case SkipState:+ stack.Push(newSkipStatement(k))+ s.Skip()+ case CommentState:+ if k.Kind == ASTKindStart {+ stack.Push(k)+ } else {+ stack.MarkComplete(k)+ }++ stmt := newCommentStatement(tok)+ stack.Push(stmt)+ default:+ return nil, NewParseError(fmt.Sprintf("invalid state with ASTKind %v and TokenType %v", k, tok))+ }++ if len(tokens) > 0 {+ tokens = tokens[1:]+ }+ }++ // this occurs when a statement has not been completed+ if stack.top > 1 {+ return nil, NewParseError(fmt.Sprintf("incomplete expression: %v", stack.container))+ }++ // returns a sublist which exludes the start symbol+ return stack.List(), nil+}++// trimSpaces will trim spaces on the left and right hand side of+// the literal.+func trimSpaces(k AST) AST {+ // trim left hand side of spaces+ for i := 0; i < len(k.Root.raw); i++ {+ if !isWhitespace(k.Root.raw[i]) {+ break+ }++ k.Root.raw = k.Root.raw[1:]+ i--+ }++ // trim right hand side of spaces+ for i := len(k.Root.raw) - 1; i >= 0; i-- {+ if !isWhitespace(k.Root.raw[i]) {+ break+ }++ k.Root.raw = k.Root.raw[:len(k.Root.raw)-1]+ }++ return k+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/literal_tokens.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/literal_tokens.gonew file mode 100644index 000000000..24df543d3--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/literal_tokens.go@@ -0,0 +1,324 @@+package ini++import (+ "fmt"+ "strconv"+ "strings"+)++var (+ runesTrue = []rune("true")+ runesFalse = []rune("false")+)++var literalValues = [][]rune{+ runesTrue,+ runesFalse,+}++func isBoolValue(b []rune) bool {+ for _, lv := range literalValues {+ if isLitValue(lv, b) {+ return true+ }+ }+ return false+}++func isLitValue(want, have []rune) bool {+ if len(have) < len(want) {+ return false+ }++ for i := 0; i < len(want); i++ {+ if want[i] != have[i] {+ return false+ }+ }++ return true+}++// isNumberValue will return whether not the leading characters in+// a byte slice is a number. A number is delimited by whitespace or+// the newline token.+//+// A number is defined to be in a binary, octal, decimal (int | float), hex format,+// or in scientific notation.+func isNumberValue(b []rune) bool {+ negativeIndex := 0+ helper := numberHelper{}+ needDigit := false++ for i := 0; i < len(b); i++ {+ negativeIndex++++ switch b[i] {+ case '-':+ if helper.IsNegative() || negativeIndex != 1 {+ return false+ }+ helper.Determine(b[i])+ needDigit = true+ continue+ case 'e', 'E':+ if err := helper.Determine(b[i]); err != nil {+ return false+ }+ negativeIndex = 0+ needDigit = true+ continue+ case 'b':+ if helper.numberFormat == hex {+ break+ }+ fallthrough+ case 'o', 'x':+ needDigit = true+ if i == 0 {+ return false+ }++ fallthrough+ case '.':+ if err := helper.Determine(b[i]); err != nil {+ return false+ }+ needDigit = true+ continue+ }++ if i > 0 && (isNewline(b[i:]) || isWhitespace(b[i])) {+ return !needDigit+ }++ if !helper.CorrectByte(b[i]) {+ return false+ }+ needDigit = false+ }++ return !needDigit+}++func isValid(b []rune) (bool, int, error) {+ if len(b) == 0 {+ // TODO: should probably return an error+ return false, 0, nil+ }++ return isValidRune(b[0]), 1, nil+}++func isValidRune(r rune) bool {+ return r != ':' && r != '=' && r != '[' && r != ']' && r != ' ' && r != '\n'+}++// ValueType is an enum that will signify what type+// the Value is+type ValueType int++func (v ValueType) String() string {+ switch v {+ case NoneType:+ return "NONE"+ case DecimalType:+ return "FLOAT"+ case IntegerType:+ return "INT"+ case StringType:+ return "STRING"+ case BoolType:+ return "BOOL"+ }++ return ""+}++// ValueType enums+const (+ NoneType = ValueType(iota)+ DecimalType+ IntegerType+ StringType+ QuotedStringType+ BoolType+)++// Value is a union container+type Value struct {+ Type ValueType+ raw []rune++ integer int64+ decimal float64+ boolean bool+ str string+}++func newValue(t ValueType, base int, raw []rune) (Value, error) {+ v := Value{+ Type: t,+ raw: raw,+ }+ var err error++ switch t {+ case DecimalType:+ v.decimal, err = strconv.ParseFloat(string(raw), 64)+ case IntegerType:+ if base != 10 {+ raw = raw[2:]+ }++ v.integer, err = strconv.ParseInt(string(raw), base, 64)+ case StringType:+ v.str = string(raw)+ case QuotedStringType:+ v.str = string(raw[1 : len(raw)-1])+ case BoolType:+ v.boolean = runeCompare(v.raw, runesTrue)+ }++ // issue 2253+ //+ // if the value trying to be parsed is too large, then we will use+ // the 'StringType' and raw value instead.+ if nerr, ok := err.(*strconv.NumError); ok && nerr.Err == strconv.ErrRange {+ v.Type = StringType+ v.str = string(raw)+ err = nil+ }++ return v, err+}++// Append will append values and change the type to a string+// type.+func (v *Value) Append(tok Token) {+ r := tok.Raw()+ if v.Type != QuotedStringType {+ v.Type = StringType+ r = tok.raw[1 : len(tok.raw)-1]+ }+ if tok.Type() != TokenLit {+ v.raw = append(v.raw, tok.Raw()...)+ } else {+ v.raw = append(v.raw, r...)+ }+}++func (v Value) String() string {+ switch v.Type {+ case DecimalType:+ return fmt.Sprintf("decimal: %f", v.decimal)+ case IntegerType:+ return fmt.Sprintf("integer: %d", v.integer)+ case StringType:+ return fmt.Sprintf("string: %s", string(v.raw))+ case QuotedStringType:+ return fmt.Sprintf("quoted string: %s", string(v.raw))+ case BoolType:+ return fmt.Sprintf("bool: %t", v.boolean)+ default:+ return "union not set"+ }+}++func newLitToken(b []rune) (Token, int, error) {+ n := 0+ var err error++ token := Token{}+ if b[0] == '"' {+ n, err = getStringValue(b)+ if err != nil {+ return token, n, err+ }++ token = newToken(TokenLit, b[:n], QuotedStringType)+ } else if isNumberValue(b) {+ var base int+ base, n, err = getNumericalValue(b)+ if err != nil {+ return token, 0, err+ }++ value := b[:n]+ vType := IntegerType+ if contains(value, '.') || hasExponent(value) {+ vType = DecimalType+ }+ token = newToken(TokenLit, value, vType)+ token.base = base+ } else if isBoolValue(b) {+ n, err = getBoolValue(b)++ token = newToken(TokenLit, b[:n], BoolType)+ } else {+ n, err = getValue(b)+ token = newToken(TokenLit, b[:n], StringType)+ }++ return token, n, err+}++// IntValue returns an integer value+func (v Value) IntValue() int64 {+ return v.integer+}++// FloatValue returns a float value+func (v Value) FloatValue() float64 {+ return v.decimal+}++// BoolValue returns a bool value+func (v Value) BoolValue() bool {+ return v.boolean+}++func isTrimmable(r rune) bool {+ switch r {+ case '\n', ' ':+ return true+ }+ return false+}++// StringValue returns the string value+func (v Value) StringValue() string {+ switch v.Type {+ case StringType:+ return strings.TrimFunc(string(v.raw), isTrimmable)+ case QuotedStringType:+ // preserve all characters in the quotes+ return string(removeEscapedCharacters(v.raw[1 : len(v.raw)-1]))+ default:+ return strings.TrimFunc(string(v.raw), isTrimmable)+ }+}++func contains(runes []rune, c rune) bool {+ for i := 0; i < len(runes); i++ {+ if runes[i] == c {+ return true+ }+ }++ return false+}++func runeCompare(v1 []rune, v2 []rune) bool {+ if len(v1) != len(v2) {+ return false+ }++ for i := 0; i < len(v1); i++ {+ if v1[i] != v2[i] {+ return false+ }+ }++ return true+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/newline_token.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/newline_token.gonew file mode 100644index 000000000..e52ac399f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/newline_token.go@@ -0,0 +1,30 @@+package ini++func isNewline(b []rune) bool {+ if len(b) == 0 {+ return false+ }++ if b[0] == '\n' {+ return true+ }++ if len(b) < 2 {+ return false+ }++ return b[0] == '\r' && b[1] == '\n'+}++func newNewlineToken(b []rune) (Token, int, error) {+ i := 1+ if b[0] == '\r' && isNewline(b[1:]) {+ i+++ }++ if !isNewline([]rune(b[:i])) {+ return emptyToken, 0, NewParseError("invalid new line token")+ }++ return newToken(TokenNL, b[:i], NoneType), i, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/number_helper.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/number_helper.gonew file mode 100644index 000000000..a45c0bc56--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/number_helper.go@@ -0,0 +1,152 @@+package ini++import (+ "bytes"+ "fmt"+ "strconv"+)++const (+ none = numberFormat(iota)+ binary+ octal+ decimal+ hex+ exponent+)++type numberFormat int++// numberHelper is used to dictate what format a number is in+// and what to do for negative values. Since -1e-4 is a valid+// number, we cannot just simply check for duplicate negatives.+type numberHelper struct {+ numberFormat numberFormat++ negative bool+ negativeExponent bool+}++func (b numberHelper) Exists() bool {+ return b.numberFormat != none+}++func (b numberHelper) IsNegative() bool {+ return b.negative || b.negativeExponent+}++func (b *numberHelper) Determine(c rune) error {+ if b.Exists() {+ return NewParseError(fmt.Sprintf("multiple number formats: 0%v", string(c)))+ }++ switch c {+ case 'b':+ b.numberFormat = binary+ case 'o':+ b.numberFormat = octal+ case 'x':+ b.numberFormat = hex+ case 'e', 'E':+ b.numberFormat = exponent+ case '-':+ if b.numberFormat != exponent {+ b.negative = true+ } else {+ b.negativeExponent = true+ }+ case '.':+ b.numberFormat = decimal+ default:+ return NewParseError(fmt.Sprintf("invalid number character: %v", string(c)))+ }++ return nil+}++func (b numberHelper) CorrectByte(c rune) bool {+ switch {+ case b.numberFormat == binary:+ if !isBinaryByte(c) {+ return false+ }+ case b.numberFormat == octal:+ if !isOctalByte(c) {+ return false+ }+ case b.numberFormat == hex:+ if !isHexByte(c) {+ return false+ }+ case b.numberFormat == decimal:+ if !isDigit(c) {+ return false+ }+ case b.numberFormat == exponent:+ if !isDigit(c) {+ return false+ }+ case b.negativeExponent:+ if !isDigit(c) {+ return false+ }+ case b.negative:+ if !isDigit(c) {+ return false+ }+ default:+ if !isDigit(c) {+ return false+ }+ }++ return true+}++func (b numberHelper) Base() int {+ switch b.numberFormat {+ case binary:+ return 2+ case octal:+ return 8+ case hex:+ return 16+ default:+ return 10+ }+}++func (b numberHelper) String() string {+ buf := bytes.Buffer{}+ i := 0++ switch b.numberFormat {+ case binary:+ i+++ buf.WriteString(strconv.Itoa(i) + ": binary format\n")+ case octal:+ i+++ buf.WriteString(strconv.Itoa(i) + ": octal format\n")+ case hex:+ i+++ buf.WriteString(strconv.Itoa(i) + ": hex format\n")+ case exponent:+ i+++ buf.WriteString(strconv.Itoa(i) + ": exponent format\n")+ default:+ i+++ buf.WriteString(strconv.Itoa(i) + ": integer format\n")+ }++ if b.negative {+ i+++ buf.WriteString(strconv.Itoa(i) + ": negative format\n")+ }++ if b.negativeExponent {+ i+++ buf.WriteString(strconv.Itoa(i) + ": negative exponent format\n")+ }++ return buf.String()+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/op_tokens.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/op_tokens.gonew file mode 100644index 000000000..8a84c7cbe--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/op_tokens.go@@ -0,0 +1,39 @@+package ini++import (+ "fmt"+)++var (+ equalOp = []rune("=")+ equalColonOp = []rune(":")+)++func isOp(b []rune) bool {+ if len(b) == 0 {+ return false+ }++ switch b[0] {+ case '=':+ return true+ case ':':+ return true+ default:+ return false+ }+}++func newOpToken(b []rune) (Token, int, error) {+ tok := Token{}++ switch b[0] {+ case '=':+ tok = newToken(TokenOp, equalOp, NoneType)+ case ':':+ tok = newToken(TokenOp, equalColonOp, NoneType)+ default:+ return tok, 0, NewParseError(fmt.Sprintf("unexpected op type, %v", b[0]))+ }+ return tok, 1, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_error.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_error.gonew file mode 100644index 000000000..457287019--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_error.go@@ -0,0 +1,43 @@+package ini++import "fmt"++const (+ // ErrCodeParseError is returned when a parsing error+ // has occurred.+ ErrCodeParseError = "INIParseError"+)++// ParseError is an error which is returned during any part of+// the parsing process.+type ParseError struct {+ msg string+}++// NewParseError will return a new ParseError where message+// is the description of the error.+func NewParseError(message string) *ParseError {+ return &ParseError{+ msg: message,+ }+}++// Code will return the ErrCodeParseError+func (err *ParseError) Code() string {+ return ErrCodeParseError+}++// Message returns the error's message+func (err *ParseError) Message() string {+ return err.msg+}++// OrigError return nothing since there will never be any+// original error.+func (err *ParseError) OrigError() error {+ return nil+}++func (err *ParseError) Error() string {+ return fmt.Sprintf("%s: %s", err.Code(), err.Message())+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_stack.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_stack.gonew file mode 100644index 000000000..7f01cf7c7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/parse_stack.go@@ -0,0 +1,60 @@+package ini++import (+ "bytes"+ "fmt"+)++// ParseStack is a stack that contains a container, the stack portion,+// and the list which is the list of ASTs that have been successfully+// parsed.+type ParseStack struct {+ top int+ container []AST+ list []AST+ index int+}++func newParseStack(sizeContainer, sizeList int) ParseStack {+ return ParseStack{+ container: make([]AST, sizeContainer),+ list: make([]AST, sizeList),+ }+}++// Pop will return and truncate the last container element.+func (s *ParseStack) Pop() AST {+ s.top--+ return s.container[s.top]+}++// Push will add the new AST to the container+func (s *ParseStack) Push(ast AST) {+ s.container[s.top] = ast+ s.top+++}++// MarkComplete will append the AST to the list of completed statements+func (s *ParseStack) MarkComplete(ast AST) {+ s.list[s.index] = ast+ s.index+++}++// List will return the completed statements+func (s ParseStack) List() []AST {+ return s.list[:s.index]+}++// Len will return the length of the container+func (s *ParseStack) Len() int {+ return s.top+}++func (s ParseStack) String() string {+ buf := bytes.Buffer{}+ for i, node := range s.list {+ buf.WriteString(fmt.Sprintf("%d: %v\n", i+1, node))+ }++ return buf.String()+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/sep_tokens.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/sep_tokens.gonew file mode 100644index 000000000..f82095ba2--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/sep_tokens.go@@ -0,0 +1,41 @@+package ini++import (+ "fmt"+)++var (+ emptyRunes = []rune{}+)++func isSep(b []rune) bool {+ if len(b) == 0 {+ return false+ }++ switch b[0] {+ case '[', ']':+ return true+ default:+ return false+ }+}++var (+ openBrace = []rune("[")+ closeBrace = []rune("]")+)++func newSepToken(b []rune) (Token, int, error) {+ tok := Token{}++ switch b[0] {+ case '[':+ tok = newToken(TokenSep, openBrace, NoneType)+ case ']':+ tok = newToken(TokenSep, closeBrace, NoneType)+ default:+ return tok, 0, NewParseError(fmt.Sprintf("unexpected sep type, %v", b[0]))+ }+ return tok, 1, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/skipper.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/skipper.gonew file mode 100644index 000000000..6bb696447--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/skipper.go@@ -0,0 +1,45 @@+package ini++// skipper is used to skip certain blocks of an ini file.+// Currently skipper is used to skip nested blocks of ini+// files. See example below+//+// [ foo ]+// nested = ; this section will be skipped+// a=b+// c=d+// bar=baz ; this will be included+type skipper struct {+ shouldSkip bool+ TokenSet bool+ prevTok Token+}++func newSkipper() skipper {+ return skipper{+ prevTok: emptyToken,+ }+}++func (s *skipper) ShouldSkip(tok Token) bool {+ if s.shouldSkip &&+ s.prevTok.Type() == TokenNL &&+ tok.Type() != TokenWS {++ s.Continue()+ return false+ }+ s.prevTok = tok++ return s.shouldSkip+}++func (s *skipper) Skip() {+ s.shouldSkip = true+ s.prevTok = emptyToken+}++func (s *skipper) Continue() {+ s.shouldSkip = false+ s.prevTok = emptyToken+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/statement.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/statement.gonew file mode 100644index 000000000..ba0af01b5--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/statement.go@@ -0,0 +1,35 @@+package ini++// Statement is an empty AST mostly used for transitioning states.+func newStatement() AST {+ return newAST(ASTKindStatement, AST{})+}++// SectionStatement represents a section AST+func newSectionStatement(tok Token) AST {+ return newASTWithRootToken(ASTKindSectionStatement, tok)+}++// ExprStatement represents a completed expression AST+func newExprStatement(ast AST) AST {+ return newAST(ASTKindExprStatement, ast)+}++// CommentStatement represents a comment in the ini defintion.+//+// grammar:+// comment -> #comment' | ;comment'+// comment' -> epsilon | value+func newCommentStatement(tok Token) AST {+ return newAST(ASTKindCommentStatement, newExpression(tok))+}++// CompletedSectionStatement represents a completed section+func newCompletedSectionStatement(ast AST) AST {+ return newAST(ASTKindCompletedSectionStatement, ast)+}++// SkipStatement is used to skip whole statements+func newSkipStatement(ast AST) AST {+ return newAST(ASTKindSkipStatement, ast)+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/value_util.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/value_util.gonew file mode 100644index 000000000..305999d29--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/value_util.go@@ -0,0 +1,284 @@+package ini++import (+ "fmt"+)++// getStringValue will return a quoted string and the amount+// of bytes read+//+// an error will be returned if the string is not properly formatted+func getStringValue(b []rune) (int, error) {+ if b[0] != '"' {+ return 0, NewParseError("strings must start with '\"'")+ }++ endQuote := false+ i := 1++ for ; i < len(b) && !endQuote; i++ {+ if escaped := isEscaped(b[:i], b[i]); b[i] == '"' && !escaped {+ endQuote = true+ break+ } else if escaped {+ /*c, err := getEscapedByte(b[i])+ if err != nil {+ return 0, err+ }++ b[i-1] = c+ b = append(b[:i], b[i+1:]...)+ i--*/++ continue+ }+ }++ if !endQuote {+ return 0, NewParseError("missing '\"' in string value")+ }++ return i + 1, nil+}++// getBoolValue will return a boolean and the amount+// of bytes read+//+// an error will be returned if the boolean is not of a correct+// value+func getBoolValue(b []rune) (int, error) {+ if len(b) < 4 {+ return 0, NewParseError("invalid boolean value")+ }++ n := 0+ for _, lv := range literalValues {+ if len(lv) > len(b) {+ continue+ }++ if isLitValue(lv, b) {+ n = len(lv)+ }+ }++ if n == 0 {+ return 0, NewParseError("invalid boolean value")+ }++ return n, nil+}++// getNumericalValue will return a numerical string, the amount+// of bytes read, and the base of the number+//+// an error will be returned if the number is not of a correct+// value+func getNumericalValue(b []rune) (int, int, error) {+ if !isDigit(b[0]) {+ return 0, 0, NewParseError("invalid digit value")+ }++ i := 0+ helper := numberHelper{}++loop:+ for negativeIndex := 0; i < len(b); i++ {+ negativeIndex++++ if !isDigit(b[i]) {+ switch b[i] {+ case '-':+ if helper.IsNegative() || negativeIndex != 1 {+ return 0, 0, NewParseError("parse error '-'")+ }++ n := getNegativeNumber(b[i:])+ i += (n - 1)+ helper.Determine(b[i])+ continue+ case '.':+ if err := helper.Determine(b[i]); err != nil {+ return 0, 0, err+ }+ case 'e', 'E':+ if err := helper.Determine(b[i]); err != nil {+ return 0, 0, err+ }++ negativeIndex = 0+ case 'b':+ if helper.numberFormat == hex {+ break+ }+ fallthrough+ case 'o', 'x':+ if i == 0 && b[i] != '0' {+ return 0, 0, NewParseError("incorrect base format, expected leading '0'")+ }++ if i != 1 {+ return 0, 0, NewParseError(fmt.Sprintf("incorrect base format found %s at %d index", string(b[i]), i))+ }++ if err := helper.Determine(b[i]); err != nil {+ return 0, 0, err+ }+ default:+ if isWhitespace(b[i]) {+ break loop+ }++ if isNewline(b[i:]) {+ break loop+ }++ if !(helper.numberFormat == hex && isHexByte(b[i])) {+ if i+2 < len(b) && !isNewline(b[i:i+2]) {+ return 0, 0, NewParseError("invalid numerical character")+ } else if !isNewline([]rune{b[i]}) {+ return 0, 0, NewParseError("invalid numerical character")+ }++ break loop+ }+ }+ }+ }++ return helper.Base(), i, nil+}++// isDigit will return whether or not something is an integer+func isDigit(b rune) bool {+ return b >= '0' && b <= '9'+}++func hasExponent(v []rune) bool {+ return contains(v, 'e') || contains(v, 'E')+}++func isBinaryByte(b rune) bool {+ switch b {+ case '0', '1':+ return true+ default:+ return false+ }+}++func isOctalByte(b rune) bool {+ switch b {+ case '0', '1', '2', '3', '4', '5', '6', '7':+ return true+ default:+ return false+ }+}++func isHexByte(b rune) bool {+ if isDigit(b) {+ return true+ }+ return (b >= 'A' && b <= 'F') ||+ (b >= 'a' && b <= 'f')+}++func getValue(b []rune) (int, error) {+ i := 0++ for i < len(b) {+ if isNewline(b[i:]) {+ break+ }++ if isOp(b[i:]) {+ break+ }++ valid, n, err := isValid(b[i:])+ if err != nil {+ return 0, err+ }++ if !valid {+ break+ }++ i += n+ }++ return i, nil+}++// getNegativeNumber will return a negative number from a+// byte slice. This will iterate through all characters until+// a non-digit has been found.+func getNegativeNumber(b []rune) int {+ if b[0] != '-' {+ return 0+ }++ i := 1+ for ; i < len(b); i++ {+ if !isDigit(b[i]) {+ return i+ }+ }++ return i+}++// isEscaped will return whether or not the character is an escaped+// character.+func isEscaped(value []rune, b rune) bool {+ if len(value) == 0 {+ return false+ }++ switch b {+ case '\'': // single quote+ case '"': // quote+ case 'n': // newline+ case 't': // tab+ case '\\': // backslash+ default:+ return false+ }++ return value[len(value)-1] == '\\'+}++func getEscapedByte(b rune) (rune, error) {+ switch b {+ case '\'': // single quote+ return '\'', nil+ case '"': // quote+ return '"', nil+ case 'n': // newline+ return '\n', nil+ case 't': // table+ return '\t', nil+ case '\\': // backslash+ return '\\', nil+ default:+ return b, NewParseError(fmt.Sprintf("invalid escaped character %c", b))+ }+}++func removeEscapedCharacters(b []rune) []rune {+ for i := 0; i < len(b); i++ {+ if isEscaped(b[:i], b[i]) {+ c, err := getEscapedByte(b[i])+ if err != nil {+ return b+ }++ b[i-1] = c+ b = append(b[:i], b[i+1:]...)+ i--+ }+ }++ return b+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/visitor.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/visitor.gonew file mode 100644index 000000000..94841c324--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/visitor.go@@ -0,0 +1,166 @@+package ini++import (+ "fmt"+ "sort"+)++// Visitor is an interface used by walkers that will+// traverse an array of ASTs.+type Visitor interface {+ VisitExpr(AST) error+ VisitStatement(AST) error+}++// DefaultVisitor is used to visit statements and expressions+// and ensure that they are both of the correct format.+// In addition, upon visiting this will build sections and populate+// the Sections field which can be used to retrieve profile+// configuration.+type DefaultVisitor struct {+ scope string+ Sections Sections+}++// NewDefaultVisitor return a DefaultVisitor+func NewDefaultVisitor() *DefaultVisitor {+ return &DefaultVisitor{+ Sections: Sections{+ container: map[string]Section{},+ },+ }+}++// VisitExpr visits expressions...+func (v *DefaultVisitor) VisitExpr(expr AST) error {+ t := v.Sections.container[v.scope]+ if t.values == nil {+ t.values = values{}+ }++ switch expr.Kind {+ case ASTKindExprStatement:+ opExpr := expr.GetRoot()+ switch opExpr.Kind {+ case ASTKindEqualExpr:+ children := opExpr.GetChildren()+ if len(children) <= 1 {+ return NewParseError("unexpected token type")+ }++ rhs := children[1]++ if rhs.Root.Type() != TokenLit {+ return NewParseError("unexpected token type")+ }++ key := EqualExprKey(opExpr)+ v, err := newValue(rhs.Root.ValueType, rhs.Root.base, rhs.Root.Raw())+ if err != nil {+ return err+ }++ t.values[key] = v+ default:+ return NewParseError(fmt.Sprintf("unsupported expression %v", expr))+ }+ default:+ return NewParseError(fmt.Sprintf("unsupported expression %v", expr))+ }++ v.Sections.container[v.scope] = t+ return nil+}++// VisitStatement visits statements...+func (v *DefaultVisitor) VisitStatement(stmt AST) error {+ switch stmt.Kind {+ case ASTKindCompletedSectionStatement:+ child := stmt.GetRoot()+ if child.Kind != ASTKindSectionStatement {+ return NewParseError(fmt.Sprintf("unsupported child statement: %T", child))+ }++ name := string(child.Root.Raw())+ v.Sections.container[name] = Section{}+ v.scope = name+ default:+ return NewParseError(fmt.Sprintf("unsupported statement: %s", stmt.Kind))+ }++ return nil+}++// Sections is a map of Section structures that represent+// a configuration.+type Sections struct {+ container map[string]Section+}++// GetSection will return section p. If section p does not exist,+// false will be returned in the second parameter.+func (t Sections) GetSection(p string) (Section, bool) {+ v, ok := t.container[p]+ return v, ok+}++// values represents a map of union values.+type values map[string]Value++// List will return a list of all sections that were successfully+// parsed.+func (t Sections) List() []string {+ keys := make([]string, len(t.container))+ i := 0+ for k := range t.container {+ keys[i] = k+ i+++ }++ sort.Strings(keys)+ return keys+}++// Section contains a name and values. This represent+// a sectioned entry in a configuration file.+type Section struct {+ Name string+ values values+}++// Has will return whether or not an entry exists in a given section+func (t Section) Has(k string) bool {+ _, ok := t.values[k]+ return ok+}++// ValueType will returned what type the union is set to. If+// k was not found, the NoneType will be returned.+func (t Section) ValueType(k string) (ValueType, bool) {+ v, ok := t.values[k]+ return v.Type, ok+}++// Bool returns a bool value at k+func (t Section) Bool(k string) bool {+ return t.values[k].BoolValue()+}++// Int returns an integer value at k+func (t Section) Int(k string) int64 {+ return t.values[k].IntValue()+}++// Float64 returns a float value at k+func (t Section) Float64(k string) float64 {+ return t.values[k].FloatValue()+}++// String returns the string value at k+func (t Section) String(k string) string {+ _, ok := t.values[k]+ if !ok {+ return ""+ }+ return t.values[k].StringValue()+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/walker.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/walker.gonew file mode 100644index 000000000..99915f7f7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/walker.go@@ -0,0 +1,25 @@+package ini++// Walk will traverse the AST using the v, the Visitor.+func Walk(tree []AST, v Visitor) error {+ for _, node := range tree {+ switch node.Kind {+ case ASTKindExpr,+ ASTKindExprStatement:++ if err := v.VisitExpr(node); err != nil {+ return err+ }+ case ASTKindStatement,+ ASTKindCompletedSectionStatement,+ ASTKindNestedSectionStatement,+ ASTKindCompletedNestedSectionStatement:++ if err := v.VisitStatement(node); err != nil {+ return err+ }+ }+ }++ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/ini/ws_token.go b/vendor/github.com/aws/aws-sdk-go/internal/ini/ws_token.gonew file mode 100644index 000000000..7ffb4ae06--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/ini/ws_token.go@@ -0,0 +1,24 @@+package ini++import (+ "unicode"+)++// isWhitespace will return whether or not the character is+// a whitespace character.+//+// Whitespace is defined as a space or tab.+func isWhitespace(c rune) bool {+ return unicode.IsSpace(c) && c != '\n' && c != '\r'+}++func newWSToken(b []rune) (Token, int, error) {+ i := 0+ for ; i < len(b); i++ {+ if !isWhitespace(b[i]) {+ break+ }+ }++ return newToken(TokenWS, b[:i], NoneType), i, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/s3err/error.go b/vendor/github.com/aws/aws-sdk-go/internal/s3err/error.gonew file mode 100644index 000000000..0b9b0dfce--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/s3err/error.go@@ -0,0 +1,57 @@+package s3err++import (+ "fmt"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++// RequestFailure provides additional S3 specific metadata for the request+// failure.+type RequestFailure struct {+ awserr.RequestFailure++ hostID string+}++// NewRequestFailure returns a request failure error decordated with S3+// specific metadata.+func NewRequestFailure(err awserr.RequestFailure, hostID string) *RequestFailure {+ return &RequestFailure{RequestFailure: err, hostID: hostID}+}++func (r RequestFailure) Error() string {+ extra := fmt.Sprintf("status code: %d, request id: %s, host id: %s",+ r.StatusCode(), r.RequestID(), r.hostID)+ return awserr.SprintError(r.Code(), r.Message(), extra, r.OrigErr())+}+func (r RequestFailure) String() string {+ return r.Error()+}++// HostID returns the HostID request response value.+func (r RequestFailure) HostID() string {+ return r.hostID+}++// RequestFailureWrapperHandler returns a handler to rap an+// awserr.RequestFailure with the S3 request ID 2 from the response.+func RequestFailureWrapperHandler() request.NamedHandler {+ return request.NamedHandler{+ Name: "awssdk.s3.errorHandler",+ Fn: func(req *request.Request) {+ reqErr, ok := req.Error.(awserr.RequestFailure)+ if !ok || reqErr == nil {+ return+ }++ hostID := req.HTTPResponse.Header.Get("X-Amz-Id-2")+ if req.Error == nil {+ return+ }++ req.Error = NewRequestFailure(reqErr, hostID)+ },+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.6.go b/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.6.gonew file mode 100644index 000000000..5aa9137e0--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.6.go@@ -0,0 +1,10 @@+// +build !go1.7++package sdkio++// Copy of Go 1.7 io package's Seeker constants.+const (+ SeekStart = 0 // seek relative to the origin of the file+ SeekCurrent = 1 // seek relative to the current offset+ SeekEnd = 2 // seek relative to the end+)diff --git a/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.7.go b/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.7.gonew file mode 100644index 000000000..e5f005613--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.7.go@@ -0,0 +1,12 @@+// +build go1.7++package sdkio++import "io"++// Alias for Go 1.7 io package Seeker constants+const (+ SeekStart = io.SeekStart // seek relative to the origin of the file+ SeekCurrent = io.SeekCurrent // seek relative to the current offset+ SeekEnd = io.SeekEnd // seek relative to the end+)diff --git a/vendor/github.com/aws/aws-sdk-go/internal/sdkrand/locked_source.go b/vendor/github.com/aws/aws-sdk-go/internal/sdkrand/locked_source.gonew file mode 100644index 000000000..0c9802d87--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/sdkrand/locked_source.go@@ -0,0 +1,29 @@+package sdkrand++import (+ "math/rand"+ "sync"+ "time"+)++// lockedSource is a thread-safe implementation of rand.Source+type lockedSource struct {+ lk sync.Mutex+ src rand.Source+}++func (r *lockedSource) Int63() (n int64) {+ r.lk.Lock()+ n = r.src.Int63()+ r.lk.Unlock()+ return+}++func (r *lockedSource) Seed(seed int64) {+ r.lk.Lock()+ r.src.Seed(seed)+ r.lk.Unlock()+}++// SeededRand is a new RNG using a thread safe implementation of rand.Source+var SeededRand = rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())})diff --git a/vendor/github.com/aws/aws-sdk-go/internal/sdkuri/path.go b/vendor/github.com/aws/aws-sdk-go/internal/sdkuri/path.gonew file mode 100644index 000000000..38ea61afe--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/sdkuri/path.go@@ -0,0 +1,23 @@+package sdkuri++import (+ "path"+ "strings"+)++// PathJoin will join the elements of the path delimited by the "/"+// character. Similar to path.Join with the exception the trailing "/"+// character is preserved if present.+func PathJoin(elems ...string) string {+ if len(elems) == 0 {+ return ""+ }++ hasTrailing := strings.HasSuffix(elems[len(elems)-1], "/")+ str := path.Join(elems...)+ if hasTrailing && str != "/" {+ str += "/"+ }++ return str+}diff --git a/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/ecs_container.go b/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/ecs_container.gonew file mode 100644index 000000000..b63e4c263--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/ecs_container.go@@ -0,0 +1,12 @@+package shareddefaults++const (+ // ECSCredsProviderEnvVar is an environmental variable key used to+ // determine which path needs to be hit.+ ECSCredsProviderEnvVar = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"+)++// ECSContainerCredentialsURI is the endpoint to retrieve container+// credentials. This can be overriden to test to ensure the credential process+// is behaving correctly.+var ECSContainerCredentialsURI = "http://169.254.170.2"diff --git a/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/shared_config.go b/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/shared_config.gonew file mode 100644index 000000000..ebcbc2b40--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/internal/shareddefaults/shared_config.go@@ -0,0 +1,40 @@+package shareddefaults++import (+ "os"+ "path/filepath"+ "runtime"+)++// SharedCredentialsFilename returns the SDK's default file path+// for the shared credentials file.+//+// Builds the shared config file path based on the OS's platform.+//+// - Linux/Unix: $HOME/.aws/credentials+// - Windows: %USERPROFILE%\.aws\credentials+func SharedCredentialsFilename() string {+ return filepath.Join(UserHomeDir(), ".aws", "credentials")+}++// SharedConfigFilename returns the SDK's default file path for+// the shared config file.+//+// Builds the shared config file path based on the OS's platform.+//+// - Linux/Unix: $HOME/.aws/config+// - Windows: %USERPROFILE%\.aws\config+func SharedConfigFilename() string {+ return filepath.Join(UserHomeDir(), ".aws", "config")+}++// UserHomeDir returns the home directory for the user the process is+// running under.+func UserHomeDir() string {+ if runtime.GOOS == "windows" { // Windows+ return os.Getenv("USERPROFILE")+ }++ // *nix+ return os.Getenv("HOME")+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.gonew file mode 100644index 000000000..ecc7bf82f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go@@ -0,0 +1,144 @@+package eventstream++import (+ "bytes"+ "encoding/base64"+ "encoding/json"+ "fmt"+ "strconv"+)++type decodedMessage struct {+ rawMessage+ Headers decodedHeaders `json:"headers"`+}+type jsonMessage struct {+ Length json.Number `json:"total_length"`+ HeadersLen json.Number `json:"headers_length"`+ PreludeCRC json.Number `json:"prelude_crc"`+ Headers decodedHeaders `json:"headers"`+ Payload []byte `json:"payload"`+ CRC json.Number `json:"message_crc"`+}++func (d *decodedMessage) UnmarshalJSON(b []byte) (err error) {+ var jsonMsg jsonMessage+ if err = json.Unmarshal(b, &jsonMsg); err != nil {+ return err+ }++ d.Length, err = numAsUint32(jsonMsg.Length)+ if err != nil {+ return err+ }+ d.HeadersLen, err = numAsUint32(jsonMsg.HeadersLen)+ if err != nil {+ return err+ }+ d.PreludeCRC, err = numAsUint32(jsonMsg.PreludeCRC)+ if err != nil {+ return err+ }+ d.Headers = jsonMsg.Headers+ d.Payload = jsonMsg.Payload+ d.CRC, err = numAsUint32(jsonMsg.CRC)+ if err != nil {+ return err+ }++ return nil+}++func (d *decodedMessage) MarshalJSON() ([]byte, error) {+ jsonMsg := jsonMessage{+ Length: json.Number(strconv.Itoa(int(d.Length))),+ HeadersLen: json.Number(strconv.Itoa(int(d.HeadersLen))),+ PreludeCRC: json.Number(strconv.Itoa(int(d.PreludeCRC))),+ Headers: d.Headers,+ Payload: d.Payload,+ CRC: json.Number(strconv.Itoa(int(d.CRC))),+ }++ return json.Marshal(jsonMsg)+}++func numAsUint32(n json.Number) (uint32, error) {+ v, err := n.Int64()+ if err != nil {+ return 0, fmt.Errorf("failed to get int64 json number, %v", err)+ }++ return uint32(v), nil+}++func (d decodedMessage) Message() Message {+ return Message{+ Headers: Headers(d.Headers),+ Payload: d.Payload,+ }+}++type decodedHeaders Headers++func (hs *decodedHeaders) UnmarshalJSON(b []byte) error {+ var jsonHeaders []struct {+ Name string `json:"name"`+ Type valueType `json:"type"`+ Value interface{} `json:"value"`+ }++ decoder := json.NewDecoder(bytes.NewReader(b))+ decoder.UseNumber()+ if err := decoder.Decode(&jsonHeaders); err != nil {+ return err+ }++ var headers Headers+ for _, h := range jsonHeaders {+ value, err := valueFromType(h.Type, h.Value)+ if err != nil {+ return err+ }+ headers.Set(h.Name, value)+ }+ (*hs) = decodedHeaders(headers)++ return nil+}++func valueFromType(typ valueType, val interface{}) (Value, error) {+ switch typ {+ case trueValueType:+ return BoolValue(true), nil+ case falseValueType:+ return BoolValue(false), nil+ case int8ValueType:+ v, err := val.(json.Number).Int64()+ return Int8Value(int8(v)), err+ case int16ValueType:+ v, err := val.(json.Number).Int64()+ return Int16Value(int16(v)), err+ case int32ValueType:+ v, err := val.(json.Number).Int64()+ return Int32Value(int32(v)), err+ case int64ValueType:+ v, err := val.(json.Number).Int64()+ return Int64Value(v), err+ case bytesValueType:+ v, err := base64.StdEncoding.DecodeString(val.(string))+ return BytesValue(v), err+ case stringValueType:+ v, err := base64.StdEncoding.DecodeString(val.(string))+ return StringValue(string(v)), err+ case timestampValueType:+ v, err := val.(json.Number).Int64()+ return TimestampValue(timeFromEpochMilli(v)), err+ case uuidValueType:+ v, err := base64.StdEncoding.DecodeString(val.(string))+ var tv UUIDValue+ copy(tv[:], v)+ return tv, err+ default:+ panic(fmt.Sprintf("unknown type, %s, %T", typ.String(), val))+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.gonew file mode 100644index 000000000..4b972b2d6--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go@@ -0,0 +1,199 @@+package eventstream++import (+ "bytes"+ "encoding/binary"+ "encoding/hex"+ "encoding/json"+ "fmt"+ "hash"+ "hash/crc32"+ "io"++ "github.com/aws/aws-sdk-go/aws"+)++// Decoder provides decoding of an Event Stream messages.+type Decoder struct {+ r io.Reader+ logger aws.Logger+}++// NewDecoder initializes and returns a Decoder for decoding event+// stream messages from the reader provided.+func NewDecoder(r io.Reader) *Decoder {+ return &Decoder{+ r: r,+ }+}++// Decode attempts to decode a single message from the event stream reader.+// Will return the event stream message, or error if Decode fails to read+// the message from the stream.+func (d *Decoder) Decode(payloadBuf []byte) (m Message, err error) {+ reader := d.r+ if d.logger != nil {+ debugMsgBuf := bytes.NewBuffer(nil)+ reader = io.TeeReader(reader, debugMsgBuf)+ defer func() {+ logMessageDecode(d.logger, debugMsgBuf, m, err)+ }()+ }++ crc := crc32.New(crc32IEEETable)+ hashReader := io.TeeReader(reader, crc)++ prelude, err := decodePrelude(hashReader, crc)+ if err != nil {+ return Message{}, err+ }++ if prelude.HeadersLen > 0 {+ lr := io.LimitReader(hashReader, int64(prelude.HeadersLen))+ m.Headers, err = decodeHeaders(lr)+ if err != nil {+ return Message{}, err+ }+ }++ if payloadLen := prelude.PayloadLen(); payloadLen > 0 {+ buf, err := decodePayload(payloadBuf, io.LimitReader(hashReader, int64(payloadLen)))+ if err != nil {+ return Message{}, err+ }+ m.Payload = buf+ }++ msgCRC := crc.Sum32()+ if err := validateCRC(reader, msgCRC); err != nil {+ return Message{}, err+ }++ return m, nil+}++// UseLogger specifies the Logger that that the decoder should use to log the+// message decode to.+func (d *Decoder) UseLogger(logger aws.Logger) {+ d.logger = logger+}++func logMessageDecode(logger aws.Logger, msgBuf *bytes.Buffer, msg Message, decodeErr error) {+ w := bytes.NewBuffer(nil)+ defer func() { logger.Log(w.String()) }()++ fmt.Fprintf(w, "Raw message:\n%s\n",+ hex.Dump(msgBuf.Bytes()))++ if decodeErr != nil {+ fmt.Fprintf(w, "Decode error: %v\n", decodeErr)+ return+ }++ rawMsg, err := msg.rawMessage()+ if err != nil {+ fmt.Fprintf(w, "failed to create raw message, %v\n", err)+ return+ }++ decodedMsg := decodedMessage{+ rawMessage: rawMsg,+ Headers: decodedHeaders(msg.Headers),+ }++ fmt.Fprintf(w, "Decoded message:\n")+ encoder := json.NewEncoder(w)+ if err := encoder.Encode(decodedMsg); err != nil {+ fmt.Fprintf(w, "failed to generate decoded message, %v\n", err)+ }+}++func decodePrelude(r io.Reader, crc hash.Hash32) (messagePrelude, error) {+ var p messagePrelude++ var err error+ p.Length, err = decodeUint32(r)+ if err != nil {+ return messagePrelude{}, err+ }++ p.HeadersLen, err = decodeUint32(r)+ if err != nil {+ return messagePrelude{}, err+ }++ if err := p.ValidateLens(); err != nil {+ return messagePrelude{}, err+ }++ preludeCRC := crc.Sum32()+ if err := validateCRC(r, preludeCRC); err != nil {+ return messagePrelude{}, err+ }++ p.PreludeCRC = preludeCRC++ return p, nil+}++func decodePayload(buf []byte, r io.Reader) ([]byte, error) {+ w := bytes.NewBuffer(buf[0:0])++ _, err := io.Copy(w, r)+ return w.Bytes(), err+}++func decodeUint8(r io.Reader) (uint8, error) {+ type byteReader interface {+ ReadByte() (byte, error)+ }++ if br, ok := r.(byteReader); ok {+ v, err := br.ReadByte()+ return uint8(v), err+ }++ var b [1]byte+ _, err := io.ReadFull(r, b[:])+ return uint8(b[0]), err+}+func decodeUint16(r io.Reader) (uint16, error) {+ var b [2]byte+ bs := b[:]+ _, err := io.ReadFull(r, bs)+ if err != nil {+ return 0, err+ }+ return binary.BigEndian.Uint16(bs), nil+}+func decodeUint32(r io.Reader) (uint32, error) {+ var b [4]byte+ bs := b[:]+ _, err := io.ReadFull(r, bs)+ if err != nil {+ return 0, err+ }+ return binary.BigEndian.Uint32(bs), nil+}+func decodeUint64(r io.Reader) (uint64, error) {+ var b [8]byte+ bs := b[:]+ _, err := io.ReadFull(r, bs)+ if err != nil {+ return 0, err+ }+ return binary.BigEndian.Uint64(bs), nil+}++func validateCRC(r io.Reader, expect uint32) error {+ msgCRC, err := decodeUint32(r)+ if err != nil {+ return err+ }++ if msgCRC != expect {+ return ChecksumError{}+ }++ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.gonew file mode 100644index 000000000..150a60981--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go@@ -0,0 +1,114 @@+package eventstream++import (+ "bytes"+ "encoding/binary"+ "hash"+ "hash/crc32"+ "io"+)++// Encoder provides EventStream message encoding.+type Encoder struct {+ w io.Writer++ headersBuf *bytes.Buffer+}++// NewEncoder initializes and returns an Encoder to encode Event Stream+// messages to an io.Writer.+func NewEncoder(w io.Writer) *Encoder {+ return &Encoder{+ w: w,+ headersBuf: bytes.NewBuffer(nil),+ }+}++// Encode encodes a single EventStream message to the io.Writer the Encoder+// was created with. An error is returned if writing the message fails.+func (e *Encoder) Encode(msg Message) error {+ e.headersBuf.Reset()++ err := encodeHeaders(e.headersBuf, msg.Headers)+ if err != nil {+ return err+ }++ crc := crc32.New(crc32IEEETable)+ hashWriter := io.MultiWriter(e.w, crc)++ headersLen := uint32(e.headersBuf.Len())+ payloadLen := uint32(len(msg.Payload))++ if err := encodePrelude(hashWriter, crc, headersLen, payloadLen); err != nil {+ return err+ }++ if headersLen > 0 {+ if _, err := io.Copy(hashWriter, e.headersBuf); err != nil {+ return err+ }+ }++ if payloadLen > 0 {+ if _, err := hashWriter.Write(msg.Payload); err != nil {+ return err+ }+ }++ msgCRC := crc.Sum32()+ return binary.Write(e.w, binary.BigEndian, msgCRC)+}++func encodePrelude(w io.Writer, crc hash.Hash32, headersLen, payloadLen uint32) error {+ p := messagePrelude{+ Length: minMsgLen + headersLen + payloadLen,+ HeadersLen: headersLen,+ }+ if err := p.ValidateLens(); err != nil {+ return err+ }++ err := binaryWriteFields(w, binary.BigEndian,+ p.Length,+ p.HeadersLen,+ )+ if err != nil {+ return err+ }++ p.PreludeCRC = crc.Sum32()+ err = binary.Write(w, binary.BigEndian, p.PreludeCRC)+ if err != nil {+ return err+ }++ return nil+}++func encodeHeaders(w io.Writer, headers Headers) error {+ for _, h := range headers {+ hn := headerName{+ Len: uint8(len(h.Name)),+ }+ copy(hn.Name[:hn.Len], h.Name)+ if err := hn.encode(w); err != nil {+ return err+ }++ if err := h.Value.encode(w); err != nil {+ return err+ }+ }++ return nil+}++func binaryWriteFields(w io.Writer, order binary.ByteOrder, vs ...interface{}) error {+ for _, v := range vs {+ if err := binary.Write(w, order, v); err != nil {+ return err+ }+ }+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.gonew file mode 100644index 000000000..5481ef307--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go@@ -0,0 +1,23 @@+package eventstream++import "fmt"++// LengthError provides the error for items being larger than a maximum length.+type LengthError struct {+ Part string+ Want int+ Have int+ Value interface{}+}++func (e LengthError) Error() string {+ return fmt.Sprintf("%s length invalid, %d/%d, %v",+ e.Part, e.Want, e.Have, e.Value)+}++// ChecksumError provides the error for message checksum invalidation errors.+type ChecksumError struct{}++func (e ChecksumError) Error() string {+ return "message checksum mismatch"+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api.gonew file mode 100644index 000000000..97937c8e5--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api.go@@ -0,0 +1,196 @@+package eventstreamapi++import (+ "fmt"+ "io"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/private/protocol"+ "github.com/aws/aws-sdk-go/private/protocol/eventstream"+)++// Unmarshaler provides the interface for unmarshaling a EventStream+// message into a SDK type.+type Unmarshaler interface {+ UnmarshalEvent(protocol.PayloadUnmarshaler, eventstream.Message) error+}++// EventStream headers with specific meaning to async API functionality.+const (+ MessageTypeHeader = `:message-type` // Identifies type of message.+ EventMessageType = `event`+ ErrorMessageType = `error`+ ExceptionMessageType = `exception`++ // Message Events+ EventTypeHeader = `:event-type` // Identifies message event type e.g. "Stats".++ // Message Error+ ErrorCodeHeader = `:error-code`+ ErrorMessageHeader = `:error-message`++ // Message Exception+ ExceptionTypeHeader = `:exception-type`+)++// EventReader provides reading from the EventStream of an reader.+type EventReader struct {+ reader io.ReadCloser+ decoder *eventstream.Decoder++ unmarshalerForEventType func(string) (Unmarshaler, error)+ payloadUnmarshaler protocol.PayloadUnmarshaler++ payloadBuf []byte+}++// NewEventReader returns a EventReader built from the reader and unmarshaler+// provided. Use ReadStream method to start reading from the EventStream.+func NewEventReader(+ reader io.ReadCloser,+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ unmarshalerForEventType func(string) (Unmarshaler, error),+) *EventReader {+ return &EventReader{+ reader: reader,+ decoder: eventstream.NewDecoder(reader),+ payloadUnmarshaler: payloadUnmarshaler,+ unmarshalerForEventType: unmarshalerForEventType,+ payloadBuf: make([]byte, 10*1024),+ }+}++// UseLogger instructs the EventReader to use the logger and log level+// specified.+func (r *EventReader) UseLogger(logger aws.Logger, logLevel aws.LogLevelType) {+ if logger != nil && logLevel.Matches(aws.LogDebugWithEventStreamBody) {+ r.decoder.UseLogger(logger)+ }+}++// ReadEvent attempts to read a message from the EventStream and return the+// unmarshaled event value that the message is for.+//+// For EventStream API errors check if the returned error satisfies the+// awserr.Error interface to get the error's Code and Message components.+//+// EventUnmarshalers called with EventStream messages must take copies of the+// message's Payload. The payload will is reused between events read.+func (r *EventReader) ReadEvent() (event interface{}, err error) {+ msg, err := r.decoder.Decode(r.payloadBuf)+ if err != nil {+ return nil, err+ }+ defer func() {+ // Reclaim payload buffer for next message read.+ r.payloadBuf = msg.Payload[0:0]+ }()++ typ, err := GetHeaderString(msg, MessageTypeHeader)+ if err != nil {+ return nil, err+ }++ switch typ {+ case EventMessageType:+ return r.unmarshalEventMessage(msg)+ case ExceptionMessageType:+ err = r.unmarshalEventException(msg)+ return nil, err+ case ErrorMessageType:+ return nil, r.unmarshalErrorMessage(msg)+ default:+ return nil, fmt.Errorf("unknown eventstream message type, %v", typ)+ }+}++func (r *EventReader) unmarshalEventMessage(+ msg eventstream.Message,+) (event interface{}, err error) {+ eventType, err := GetHeaderString(msg, EventTypeHeader)+ if err != nil {+ return nil, err+ }++ ev, err := r.unmarshalerForEventType(eventType)+ if err != nil {+ return nil, err+ }++ err = ev.UnmarshalEvent(r.payloadUnmarshaler, msg)+ if err != nil {+ return nil, err+ }++ return ev, nil+}++func (r *EventReader) unmarshalEventException(+ msg eventstream.Message,+) (err error) {+ eventType, err := GetHeaderString(msg, ExceptionTypeHeader)+ if err != nil {+ return err+ }++ ev, err := r.unmarshalerForEventType(eventType)+ if err != nil {+ return err+ }++ err = ev.UnmarshalEvent(r.payloadUnmarshaler, msg)+ if err != nil {+ return err+ }++ var ok bool+ err, ok = ev.(error)+ if !ok {+ err = messageError{+ code: "SerializationError",+ msg: fmt.Sprintf(+ "event stream exception %s mapped to non-error %T, %v",+ eventType, ev, ev,+ ),+ }+ }++ return err+}++func (r *EventReader) unmarshalErrorMessage(msg eventstream.Message) (err error) {+ var msgErr messageError++ msgErr.code, err = GetHeaderString(msg, ErrorCodeHeader)+ if err != nil {+ return err+ }++ msgErr.msg, err = GetHeaderString(msg, ErrorMessageHeader)+ if err != nil {+ return err+ }++ return msgErr+}++// Close closes the EventReader's EventStream reader.+func (r *EventReader) Close() error {+ return r.reader.Close()+}++// GetHeaderString returns the value of the header as a string. If the header+// is not set or the value is not a string an error will be returned.+func GetHeaderString(msg eventstream.Message, headerName string) (string, error) {+ headerVal := msg.Headers.Get(headerName)+ if headerVal == nil {+ return "", fmt.Errorf("error header %s not present", headerName)+ }++ v, ok := headerVal.Get().(string)+ if !ok {+ return "", fmt.Errorf("error header value is not a string, %T", headerVal)+ }++ return v, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.gonew file mode 100644index 000000000..5ea5a988b--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go@@ -0,0 +1,24 @@+package eventstreamapi++import "fmt"++type messageError struct {+ code string+ msg string+}++func (e messageError) Code() string {+ return e.code+}++func (e messageError) Message() string {+ return e.msg+}++func (e messageError) Error() string {+ return fmt.Sprintf("%s: %s", e.code, e.msg)+}++func (e messageError) OrigErr() error {+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.gonew file mode 100644index 000000000..3b44dde2f--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go@@ -0,0 +1,166 @@+package eventstream++import (+ "encoding/binary"+ "fmt"+ "io"+)++// Headers are a collection of EventStream header values.+type Headers []Header++// Header is a single EventStream Key Value header pair.+type Header struct {+ Name string+ Value Value+}++// Set associates the name with a value. If the header name already exists in+// the Headers the value will be replaced with the new one.+func (hs *Headers) Set(name string, value Value) {+ var i int+ for ; i < len(*hs); i++ {+ if (*hs)[i].Name == name {+ (*hs)[i].Value = value+ return+ }+ }++ *hs = append(*hs, Header{+ Name: name, Value: value,+ })+}++// Get returns the Value associated with the header. Nil is returned if the+// value does not exist.+func (hs Headers) Get(name string) Value {+ for i := 0; i < len(hs); i++ {+ if h := hs[i]; h.Name == name {+ return h.Value+ }+ }+ return nil+}++// Del deletes the value in the Headers if it exists.+func (hs *Headers) Del(name string) {+ for i := 0; i < len(*hs); i++ {+ if (*hs)[i].Name == name {+ copy((*hs)[i:], (*hs)[i+1:])+ (*hs) = (*hs)[:len(*hs)-1]+ }+ }+}++func decodeHeaders(r io.Reader) (Headers, error) {+ hs := Headers{}++ for {+ name, err := decodeHeaderName(r)+ if err != nil {+ if err == io.EOF {+ // EOF while getting header name means no more headers+ break+ }+ return nil, err+ }++ value, err := decodeHeaderValue(r)+ if err != nil {+ return nil, err+ }++ hs.Set(name, value)+ }++ return hs, nil+}++func decodeHeaderName(r io.Reader) (string, error) {+ var n headerName++ var err error+ n.Len, err = decodeUint8(r)+ if err != nil {+ return "", err+ }++ name := n.Name[:n.Len]+ if _, err := io.ReadFull(r, name); err != nil {+ return "", err+ }++ return string(name), nil+}++func decodeHeaderValue(r io.Reader) (Value, error) {+ var raw rawValue++ typ, err := decodeUint8(r)+ if err != nil {+ return nil, err+ }+ raw.Type = valueType(typ)++ var v Value++ switch raw.Type {+ case trueValueType:+ v = BoolValue(true)+ case falseValueType:+ v = BoolValue(false)+ case int8ValueType:+ var tv Int8Value+ err = tv.decode(r)+ v = tv+ case int16ValueType:+ var tv Int16Value+ err = tv.decode(r)+ v = tv+ case int32ValueType:+ var tv Int32Value+ err = tv.decode(r)+ v = tv+ case int64ValueType:+ var tv Int64Value+ err = tv.decode(r)+ v = tv+ case bytesValueType:+ var tv BytesValue+ err = tv.decode(r)+ v = tv+ case stringValueType:+ var tv StringValue+ err = tv.decode(r)+ v = tv+ case timestampValueType:+ var tv TimestampValue+ err = tv.decode(r)+ v = tv+ case uuidValueType:+ var tv UUIDValue+ err = tv.decode(r)+ v = tv+ default:+ panic(fmt.Sprintf("unknown value type %d", raw.Type))+ }++ // Error could be EOF, let caller deal with it+ return v, err+}++const maxHeaderNameLen = 255++type headerName struct {+ Len uint8+ Name [maxHeaderNameLen]byte+}++func (v headerName) encode(w io.Writer) error {+ if err := binary.Write(w, binary.BigEndian, v.Len); err != nil {+ return err+ }++ _, err := w.Write(v.Name[:v.Len])+ return err+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.gonew file mode 100644index 000000000..e3fc0766a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go@@ -0,0 +1,501 @@+package eventstream++import (+ "encoding/base64"+ "encoding/binary"+ "fmt"+ "io"+ "strconv"+ "time"+)++const maxHeaderValueLen = 1<<15 - 1 // 2^15-1 or 32KB - 1++// valueType is the EventStream header value type.+type valueType uint8++// Header value types+const (+ trueValueType valueType = iota+ falseValueType+ int8ValueType // Byte+ int16ValueType // Short+ int32ValueType // Integer+ int64ValueType // Long+ bytesValueType+ stringValueType+ timestampValueType+ uuidValueType+)++func (t valueType) String() string {+ switch t {+ case trueValueType:+ return "bool"+ case falseValueType:+ return "bool"+ case int8ValueType:+ return "int8"+ case int16ValueType:+ return "int16"+ case int32ValueType:+ return "int32"+ case int64ValueType:+ return "int64"+ case bytesValueType:+ return "byte_array"+ case stringValueType:+ return "string"+ case timestampValueType:+ return "timestamp"+ case uuidValueType:+ return "uuid"+ default:+ return fmt.Sprintf("unknown value type %d", uint8(t))+ }+}++type rawValue struct {+ Type valueType+ Len uint16 // Only set for variable length slices+ Value []byte // byte representation of value, BigEndian encoding.+}++func (r rawValue) encodeScalar(w io.Writer, v interface{}) error {+ return binaryWriteFields(w, binary.BigEndian,+ r.Type,+ v,+ )+}++func (r rawValue) encodeFixedSlice(w io.Writer, v []byte) error {+ binary.Write(w, binary.BigEndian, r.Type)++ _, err := w.Write(v)+ return err+}++func (r rawValue) encodeBytes(w io.Writer, v []byte) error {+ if len(v) > maxHeaderValueLen {+ return LengthError{+ Part: "header value",+ Want: maxHeaderValueLen, Have: len(v),+ Value: v,+ }+ }+ r.Len = uint16(len(v))++ err := binaryWriteFields(w, binary.BigEndian,+ r.Type,+ r.Len,+ )+ if err != nil {+ return err+ }++ _, err = w.Write(v)+ return err+}++func (r rawValue) encodeString(w io.Writer, v string) error {+ if len(v) > maxHeaderValueLen {+ return LengthError{+ Part: "header value",+ Want: maxHeaderValueLen, Have: len(v),+ Value: v,+ }+ }+ r.Len = uint16(len(v))++ type stringWriter interface {+ WriteString(string) (int, error)+ }++ err := binaryWriteFields(w, binary.BigEndian,+ r.Type,+ r.Len,+ )+ if err != nil {+ return err+ }++ if sw, ok := w.(stringWriter); ok {+ _, err = sw.WriteString(v)+ } else {+ _, err = w.Write([]byte(v))+ }++ return err+}++func decodeFixedBytesValue(r io.Reader, buf []byte) error {+ _, err := io.ReadFull(r, buf)+ return err+}++func decodeBytesValue(r io.Reader) ([]byte, error) {+ var raw rawValue+ var err error+ raw.Len, err = decodeUint16(r)+ if err != nil {+ return nil, err+ }++ buf := make([]byte, raw.Len)+ _, err = io.ReadFull(r, buf)+ if err != nil {+ return nil, err+ }++ return buf, nil+}++func decodeStringValue(r io.Reader) (string, error) {+ v, err := decodeBytesValue(r)+ return string(v), err+}++// Value represents the abstract header value.+type Value interface {+ Get() interface{}+ String() string+ valueType() valueType+ encode(io.Writer) error+}++// An BoolValue provides eventstream encoding, and representation+// of a Go bool value.+type BoolValue bool++// Get returns the underlying type+func (v BoolValue) Get() interface{} {+ return bool(v)+}++// valueType returns the EventStream header value type value.+func (v BoolValue) valueType() valueType {+ if v {+ return trueValueType+ }+ return falseValueType+}++func (v BoolValue) String() string {+ return strconv.FormatBool(bool(v))+}++// encode encodes the BoolValue into an eventstream binary value+// representation.+func (v BoolValue) encode(w io.Writer) error {+ return binary.Write(w, binary.BigEndian, v.valueType())+}++// An Int8Value provides eventstream encoding, and representation of a Go+// int8 value.+type Int8Value int8++// Get returns the underlying value.+func (v Int8Value) Get() interface{} {+ return int8(v)+}++// valueType returns the EventStream header value type value.+func (Int8Value) valueType() valueType {+ return int8ValueType+}++func (v Int8Value) String() string {+ return fmt.Sprintf("0x%02x", int8(v))+}++// encode encodes the Int8Value into an eventstream binary value+// representation.+func (v Int8Value) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }++ return raw.encodeScalar(w, v)+}++func (v *Int8Value) decode(r io.Reader) error {+ n, err := decodeUint8(r)+ if err != nil {+ return err+ }++ *v = Int8Value(n)+ return nil+}++// An Int16Value provides eventstream encoding, and representation of a Go+// int16 value.+type Int16Value int16++// Get returns the underlying value.+func (v Int16Value) Get() interface{} {+ return int16(v)+}++// valueType returns the EventStream header value type value.+func (Int16Value) valueType() valueType {+ return int16ValueType+}++func (v Int16Value) String() string {+ return fmt.Sprintf("0x%04x", int16(v))+}++// encode encodes the Int16Value into an eventstream binary value+// representation.+func (v Int16Value) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }+ return raw.encodeScalar(w, v)+}++func (v *Int16Value) decode(r io.Reader) error {+ n, err := decodeUint16(r)+ if err != nil {+ return err+ }++ *v = Int16Value(n)+ return nil+}++// An Int32Value provides eventstream encoding, and representation of a Go+// int32 value.+type Int32Value int32++// Get returns the underlying value.+func (v Int32Value) Get() interface{} {+ return int32(v)+}++// valueType returns the EventStream header value type value.+func (Int32Value) valueType() valueType {+ return int32ValueType+}++func (v Int32Value) String() string {+ return fmt.Sprintf("0x%08x", int32(v))+}++// encode encodes the Int32Value into an eventstream binary value+// representation.+func (v Int32Value) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }+ return raw.encodeScalar(w, v)+}++func (v *Int32Value) decode(r io.Reader) error {+ n, err := decodeUint32(r)+ if err != nil {+ return err+ }++ *v = Int32Value(n)+ return nil+}++// An Int64Value provides eventstream encoding, and representation of a Go+// int64 value.+type Int64Value int64++// Get returns the underlying value.+func (v Int64Value) Get() interface{} {+ return int64(v)+}++// valueType returns the EventStream header value type value.+func (Int64Value) valueType() valueType {+ return int64ValueType+}++func (v Int64Value) String() string {+ return fmt.Sprintf("0x%016x", int64(v))+}++// encode encodes the Int64Value into an eventstream binary value+// representation.+func (v Int64Value) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }+ return raw.encodeScalar(w, v)+}++func (v *Int64Value) decode(r io.Reader) error {+ n, err := decodeUint64(r)+ if err != nil {+ return err+ }++ *v = Int64Value(n)+ return nil+}++// An BytesValue provides eventstream encoding, and representation of a Go+// byte slice.+type BytesValue []byte++// Get returns the underlying value.+func (v BytesValue) Get() interface{} {+ return []byte(v)+}++// valueType returns the EventStream header value type value.+func (BytesValue) valueType() valueType {+ return bytesValueType+}++func (v BytesValue) String() string {+ return base64.StdEncoding.EncodeToString([]byte(v))+}++// encode encodes the BytesValue into an eventstream binary value+// representation.+func (v BytesValue) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }++ return raw.encodeBytes(w, []byte(v))+}++func (v *BytesValue) decode(r io.Reader) error {+ buf, err := decodeBytesValue(r)+ if err != nil {+ return err+ }++ *v = BytesValue(buf)+ return nil+}++// An StringValue provides eventstream encoding, and representation of a Go+// string.+type StringValue string++// Get returns the underlying value.+func (v StringValue) Get() interface{} {+ return string(v)+}++// valueType returns the EventStream header value type value.+func (StringValue) valueType() valueType {+ return stringValueType+}++func (v StringValue) String() string {+ return string(v)+}++// encode encodes the StringValue into an eventstream binary value+// representation.+func (v StringValue) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }++ return raw.encodeString(w, string(v))+}++func (v *StringValue) decode(r io.Reader) error {+ s, err := decodeStringValue(r)+ if err != nil {+ return err+ }++ *v = StringValue(s)+ return nil+}++// An TimestampValue provides eventstream encoding, and representation of a Go+// timestamp.+type TimestampValue time.Time++// Get returns the underlying value.+func (v TimestampValue) Get() interface{} {+ return time.Time(v)+}++// valueType returns the EventStream header value type value.+func (TimestampValue) valueType() valueType {+ return timestampValueType+}++func (v TimestampValue) epochMilli() int64 {+ nano := time.Time(v).UnixNano()+ msec := nano / int64(time.Millisecond)+ return msec+}++func (v TimestampValue) String() string {+ msec := v.epochMilli()+ return strconv.FormatInt(msec, 10)+}++// encode encodes the TimestampValue into an eventstream binary value+// representation.+func (v TimestampValue) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }++ msec := v.epochMilli()+ return raw.encodeScalar(w, msec)+}++func (v *TimestampValue) decode(r io.Reader) error {+ n, err := decodeUint64(r)+ if err != nil {+ return err+ }++ *v = TimestampValue(timeFromEpochMilli(int64(n)))+ return nil+}++func timeFromEpochMilli(t int64) time.Time {+ secs := t / 1e3+ msec := t % 1e3+ return time.Unix(secs, msec*int64(time.Millisecond)).UTC()+}++// An UUIDValue provides eventstream encoding, and representation of a UUID+// value.+type UUIDValue [16]byte++// Get returns the underlying value.+func (v UUIDValue) Get() interface{} {+ return v[:]+}++// valueType returns the EventStream header value type value.+func (UUIDValue) valueType() valueType {+ return uuidValueType+}++func (v UUIDValue) String() string {+ return fmt.Sprintf(`%X-%X-%X-%X-%X`, v[0:4], v[4:6], v[6:8], v[8:10], v[10:])+}++// encode encodes the UUIDValue into an eventstream binary value+// representation.+func (v UUIDValue) encode(w io.Writer) error {+ raw := rawValue{+ Type: v.valueType(),+ }++ return raw.encodeFixedSlice(w, v[:])+}++func (v *UUIDValue) decode(r io.Reader) error {+ tv := (*v)[:]+ return decodeFixedBytesValue(r, tv)+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.gonew file mode 100644index 000000000..2dc012a66--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go@@ -0,0 +1,103 @@+package eventstream++import (+ "bytes"+ "encoding/binary"+ "hash/crc32"+)++const preludeLen = 8+const preludeCRCLen = 4+const msgCRCLen = 4+const minMsgLen = preludeLen + preludeCRCLen + msgCRCLen+const maxPayloadLen = 1024 * 1024 * 16 // 16MB+const maxHeadersLen = 1024 * 128 // 128KB+const maxMsgLen = minMsgLen + maxHeadersLen + maxPayloadLen++var crc32IEEETable = crc32.MakeTable(crc32.IEEE)++// A Message provides the eventstream message representation.+type Message struct {+ Headers Headers+ Payload []byte+}++func (m *Message) rawMessage() (rawMessage, error) {+ var raw rawMessage++ if len(m.Headers) > 0 {+ var headers bytes.Buffer+ if err := encodeHeaders(&headers, m.Headers); err != nil {+ return rawMessage{}, err+ }+ raw.Headers = headers.Bytes()+ raw.HeadersLen = uint32(len(raw.Headers))+ }++ raw.Length = raw.HeadersLen + uint32(len(m.Payload)) + minMsgLen++ hash := crc32.New(crc32IEEETable)+ binaryWriteFields(hash, binary.BigEndian, raw.Length, raw.HeadersLen)+ raw.PreludeCRC = hash.Sum32()++ binaryWriteFields(hash, binary.BigEndian, raw.PreludeCRC)++ if raw.HeadersLen > 0 {+ hash.Write(raw.Headers)+ }++ // Read payload bytes and update hash for it as well.+ if len(m.Payload) > 0 {+ raw.Payload = m.Payload+ hash.Write(raw.Payload)+ }++ raw.CRC = hash.Sum32()++ return raw, nil+}++type messagePrelude struct {+ Length uint32+ HeadersLen uint32+ PreludeCRC uint32+}++func (p messagePrelude) PayloadLen() uint32 {+ return p.Length - p.HeadersLen - minMsgLen+}++func (p messagePrelude) ValidateLens() error {+ if p.Length == 0 || p.Length > maxMsgLen {+ return LengthError{+ Part: "message prelude",+ Want: maxMsgLen,+ Have: int(p.Length),+ }+ }+ if p.HeadersLen > maxHeadersLen {+ return LengthError{+ Part: "message headers",+ Want: maxHeadersLen,+ Have: int(p.HeadersLen),+ }+ }+ if payloadLen := p.PayloadLen(); payloadLen > maxPayloadLen {+ return LengthError{+ Part: "message payload",+ Want: maxPayloadLen,+ Have: int(payloadLen),+ }+ }++ return nil+}++type rawMessage struct {+ messagePrelude++ Headers []byte+ Payload []byte++ CRC uint32+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/host.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/host.gonew file mode 100644index 000000000..d7d42db0a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/host.go@@ -0,0 +1,68 @@+package protocol++import (+ "strings"++ "github.com/aws/aws-sdk-go/aws/request"+)++// ValidateEndpointHostHandler is a request handler that will validate the+// request endpoint's hosts is a valid RFC 3986 host.+var ValidateEndpointHostHandler = request.NamedHandler{+ Name: "awssdk.protocol.ValidateEndpointHostHandler",+ Fn: func(r *request.Request) {+ err := ValidateEndpointHost(r.Operation.Name, r.HTTPRequest.URL.Host)+ if err != nil {+ r.Error = err+ }+ },+}++// ValidateEndpointHost validates that the host string passed in is a valid RFC+// 3986 host. Returns error if the host is not valid.+func ValidateEndpointHost(opName, host string) error {+ paramErrs := request.ErrInvalidParams{Context: opName}+ labels := strings.Split(host, ".")++ for i, label := range labels {+ if i == len(labels)-1 && len(label) == 0 {+ // Allow trailing dot for FQDN hosts.+ continue+ }++ if !ValidHostLabel(label) {+ paramErrs.Add(request.NewErrParamFormat(+ "endpoint host label", "[a-zA-Z0-9-]{1,63}", label))+ }+ }++ if len(host) > 255 {+ paramErrs.Add(request.NewErrParamMaxLen(+ "endpoint host", 255, host,+ ))+ }++ if paramErrs.Len() > 0 {+ return paramErrs+ }+ return nil+}++// ValidHostLabel returns if the label is a valid RFC 3986 host label.+func ValidHostLabel(label string) bool {+ if l := len(label); l == 0 || l > 63 {+ return false+ }+ for _, r := range label {+ switch {+ case r >= '0' && r <= '9':+ case r >= 'A' && r <= 'Z':+ case r >= 'a' && r <= 'z':+ case r == '-':+ default:+ return false+ }+ }++ return true+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/host_prefix.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/host_prefix.gonew file mode 100644index 000000000..915b0fcaf--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/host_prefix.go@@ -0,0 +1,54 @@+package protocol++import (+ "strings"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/request"+)++// HostPrefixHandlerName is the handler name for the host prefix request+// handler.+const HostPrefixHandlerName = "awssdk.endpoint.HostPrefixHandler"++// NewHostPrefixHandler constructs a build handler+func NewHostPrefixHandler(prefix string, labelsFn func() map[string]string) request.NamedHandler {+ builder := HostPrefixBuilder{+ Prefix: prefix,+ LabelsFn: labelsFn,+ }++ return request.NamedHandler{+ Name: HostPrefixHandlerName,+ Fn: builder.Build,+ }+}++// HostPrefixBuilder provides the request handler to expand and prepend+// the host prefix into the operation's request endpoint host.+type HostPrefixBuilder struct {+ Prefix string+ LabelsFn func() map[string]string+}++// Build updates the passed in Request with the HostPrefix template expanded.+func (h HostPrefixBuilder) Build(r *request.Request) {+ if aws.BoolValue(r.Config.DisableEndpointHostPrefix) {+ return+ }++ var labels map[string]string+ if h.LabelsFn != nil {+ labels = h.LabelsFn()+ }++ prefix := h.Prefix+ for name, value := range labels {+ prefix = strings.Replace(prefix, "{"+name+"}", value, -1)+ }++ r.HTTPRequest.URL.Host = prefix + r.HTTPRequest.URL.Host+ if len(r.HTTPRequest.Host) > 0 {+ r.HTTPRequest.Host = prefix + r.HTTPRequest.Host+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.gonew file mode 100644index 000000000..53831dff9--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency.go@@ -0,0 +1,75 @@+package protocol++import (+ "crypto/rand"+ "fmt"+ "reflect"+)++// RandReader is the random reader the protocol package will use to read+// random bytes from. This is exported for testing, and should not be used.+var RandReader = rand.Reader++const idempotencyTokenFillTag = `idempotencyToken`++// CanSetIdempotencyToken returns true if the struct field should be+// automatically populated with a Idempotency token.+//+// Only *string and string type fields that are tagged with idempotencyToken+// which are not already set can be auto filled.+func CanSetIdempotencyToken(v reflect.Value, f reflect.StructField) bool {+ switch u := v.Interface().(type) {+ // To auto fill an Idempotency token the field must be a string,+ // tagged for auto fill, and have a zero value.+ case *string:+ return u == nil && len(f.Tag.Get(idempotencyTokenFillTag)) != 0+ case string:+ return len(u) == 0 && len(f.Tag.Get(idempotencyTokenFillTag)) != 0+ }++ return false+}++// GetIdempotencyToken returns a randomly generated idempotency token.+func GetIdempotencyToken() string {+ b := make([]byte, 16)+ RandReader.Read(b)++ return UUIDVersion4(b)+}++// SetIdempotencyToken will set the value provided with a Idempotency Token.+// Given that the value can be set. Will panic if value is not setable.+func SetIdempotencyToken(v reflect.Value) {+ if v.Kind() == reflect.Ptr {+ if v.IsNil() && v.CanSet() {+ v.Set(reflect.New(v.Type().Elem()))+ }+ v = v.Elem()+ }+ v = reflect.Indirect(v)++ if !v.CanSet() {+ panic(fmt.Sprintf("unable to set idempotnecy token %v", v))+ }++ b := make([]byte, 16)+ _, err := rand.Read(b)+ if err != nil {+ // TODO handle error+ return+ }++ v.Set(reflect.ValueOf(UUIDVersion4(b)))+}++// UUIDVersion4 returns a Version 4 random UUID from the byte slice provided+func UUIDVersion4(u []byte) string {+ // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_.28random.29+ // 13th character is "4"+ u[6] = (u[6] | 0x40) & 0x4F+ // 17th character is "8", "9", "a", or "b"+ u[8] = (u[8] | 0x80) & 0xBF++ return fmt.Sprintf(`%X-%X-%X-%X-%X`, u[0:4], u[4:6], u[6:8], u[8:10], u[10:])+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonvalue.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonvalue.gonew file mode 100644index 000000000..776d11018--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/jsonvalue.go@@ -0,0 +1,76 @@+package protocol++import (+ "encoding/base64"+ "encoding/json"+ "fmt"+ "strconv"++ "github.com/aws/aws-sdk-go/aws"+)++// EscapeMode is the mode that should be use for escaping a value+type EscapeMode uint++// The modes for escaping a value before it is marshaled, and unmarshaled.+const (+ NoEscape EscapeMode = iota+ Base64Escape+ QuotedEscape+)++// EncodeJSONValue marshals the value into a JSON string, and optionally base64+// encodes the string before returning it.+//+// Will panic if the escape mode is unknown.+func EncodeJSONValue(v aws.JSONValue, escape EscapeMode) (string, error) {+ b, err := json.Marshal(v)+ if err != nil {+ return "", err+ }++ switch escape {+ case NoEscape:+ return string(b), nil+ case Base64Escape:+ return base64.StdEncoding.EncodeToString(b), nil+ case QuotedEscape:+ return strconv.Quote(string(b)), nil+ }++ panic(fmt.Sprintf("EncodeJSONValue called with unknown EscapeMode, %v", escape))+}++// DecodeJSONValue will attempt to decode the string input as a JSONValue.+// Optionally decoding base64 the value first before JSON unmarshaling.+//+// Will panic if the escape mode is unknown.+func DecodeJSONValue(v string, escape EscapeMode) (aws.JSONValue, error) {+ var b []byte+ var err error++ switch escape {+ case NoEscape:+ b = []byte(v)+ case Base64Escape:+ b, err = base64.StdEncoding.DecodeString(v)+ case QuotedEscape:+ var u string+ u, err = strconv.Unquote(v)+ b = []byte(u)+ default:+ panic(fmt.Sprintf("DecodeJSONValue called with unknown EscapeMode, %v", escape))+ }++ if err != nil {+ return nil, err+ }++ m := aws.JSONValue{}+ err = json.Unmarshal(b, &m)+ if err != nil {+ return nil, err+ }++ return m, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/payload.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/payload.gonew file mode 100644index 000000000..e21614a12--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/payload.go@@ -0,0 +1,81 @@+package protocol++import (+ "io"+ "io/ioutil"+ "net/http"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/request"+)++// PayloadUnmarshaler provides the interface for unmarshaling a payload's+// reader into a SDK shape.+type PayloadUnmarshaler interface {+ UnmarshalPayload(io.Reader, interface{}) error+}++// HandlerPayloadUnmarshal implements the PayloadUnmarshaler from a+// HandlerList. This provides the support for unmarshaling a payload reader to+// a shape without needing a SDK request first.+type HandlerPayloadUnmarshal struct {+ Unmarshalers request.HandlerList+}++// UnmarshalPayload unmarshals the io.Reader payload into the SDK shape using+// the Unmarshalers HandlerList provided. Returns an error if unable+// unmarshaling fails.+func (h HandlerPayloadUnmarshal) UnmarshalPayload(r io.Reader, v interface{}) error {+ req := &request.Request{+ HTTPRequest: &http.Request{},+ HTTPResponse: &http.Response{+ StatusCode: 200,+ Header: http.Header{},+ Body: ioutil.NopCloser(r),+ },+ Data: v,+ }++ h.Unmarshalers.Run(req)++ return req.Error+}++// PayloadMarshaler provides the interface for marshaling a SDK shape into and+// io.Writer.+type PayloadMarshaler interface {+ MarshalPayload(io.Writer, interface{}) error+}++// HandlerPayloadMarshal implements the PayloadMarshaler from a HandlerList.+// This provides support for marshaling a SDK shape into an io.Writer without+// needing a SDK request first.+type HandlerPayloadMarshal struct {+ Marshalers request.HandlerList+}++// MarshalPayload marshals the SDK shape into the io.Writer using the+// Marshalers HandlerList provided. Returns an error if unable if marshal+// fails.+func (h HandlerPayloadMarshal) MarshalPayload(w io.Writer, v interface{}) error {+ req := request.New(+ aws.Config{},+ metadata.ClientInfo{},+ request.Handlers{},+ nil,+ &request.Operation{HTTPMethod: "GET"},+ v,+ nil,+ )++ h.Marshalers.Run(req)++ if req.Error != nil {+ return req.Error+ }++ io.Copy(w, req.GetBody())++ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.gonew file mode 100644index 000000000..60e5b09d5--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go@@ -0,0 +1,36 @@+// Package query provides serialization of AWS query requests, and responses.+package query++//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/query.json build_test.go++import (+ "net/url"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol/query/queryutil"+)++// BuildHandler is a named request handler for building query protocol requests+var BuildHandler = request.NamedHandler{Name: "awssdk.query.Build", Fn: Build}++// Build builds a request for an AWS Query service.+func Build(r *request.Request) {+ body := url.Values{+ "Action": {r.Operation.Name},+ "Version": {r.ClientInfo.APIVersion},+ }+ if err := queryutil.Parse(body, r.Params, false); err != nil {+ r.Error = awserr.New("SerializationError", "failed encoding Query request", err)+ return+ }++ if !r.IsPresigned() {+ r.HTTPRequest.Method = "POST"+ r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")+ r.SetBufferBody([]byte(body.Encode()))+ } else { // This is a pre-signed request+ r.HTTPRequest.Method = "GET"+ r.HTTPRequest.URL.RawQuery = body.Encode()+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.gonew file mode 100644index 000000000..75866d012--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go@@ -0,0 +1,246 @@+package queryutil++import (+ "encoding/base64"+ "fmt"+ "net/url"+ "reflect"+ "sort"+ "strconv"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/private/protocol"+)++// Parse parses an object i and fills a url.Values object. The isEC2 flag+// indicates if this is the EC2 Query sub-protocol.+func Parse(body url.Values, i interface{}, isEC2 bool) error {+ q := queryParser{isEC2: isEC2}+ return q.parseValue(body, reflect.ValueOf(i), "", "")+}++func elemOf(value reflect.Value) reflect.Value {+ for value.Kind() == reflect.Ptr {+ value = value.Elem()+ }+ return value+}++type queryParser struct {+ isEC2 bool+}++func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {+ value = elemOf(value)++ // no need to handle zero values+ if !value.IsValid() {+ return nil+ }++ t := tag.Get("type")+ if t == "" {+ switch value.Kind() {+ case reflect.Struct:+ t = "structure"+ case reflect.Slice:+ t = "list"+ case reflect.Map:+ t = "map"+ }+ }++ switch t {+ case "structure":+ return q.parseStruct(v, value, prefix)+ case "list":+ return q.parseList(v, value, prefix, tag)+ case "map":+ return q.parseMap(v, value, prefix, tag)+ default:+ return q.parseScalar(v, value, prefix, tag)+ }+}++func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {+ if !value.IsValid() {+ return nil+ }++ t := value.Type()+ for i := 0; i < value.NumField(); i++ {+ elemValue := elemOf(value.Field(i))+ field := t.Field(i)++ if field.PkgPath != "" {+ continue // ignore unexported fields+ }+ if field.Tag.Get("ignore") != "" {+ continue+ }++ if protocol.CanSetIdempotencyToken(value.Field(i), field) {+ token := protocol.GetIdempotencyToken()+ elemValue = reflect.ValueOf(token)+ }++ var name string+ if q.isEC2 {+ name = field.Tag.Get("queryName")+ }+ if name == "" {+ if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {+ name = field.Tag.Get("locationNameList")+ } else if locName := field.Tag.Get("locationName"); locName != "" {+ name = locName+ }+ if name != "" && q.isEC2 {+ name = strings.ToUpper(name[0:1]) + name[1:]+ }+ }+ if name == "" {+ name = field.Name+ }++ if prefix != "" {+ name = prefix + "." + name+ }++ if err := q.parseValue(v, elemValue, name, field.Tag); err != nil {+ return err+ }+ }+ return nil+}++func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {+ // If it's empty, generate an empty value+ if !value.IsNil() && value.Len() == 0 {+ v.Set(prefix, "")+ return nil+ }++ if _, ok := value.Interface().([]byte); ok {+ return q.parseScalar(v, value, prefix, tag)+ }++ // check for unflattened list member+ if !q.isEC2 && tag.Get("flattened") == "" {+ if listName := tag.Get("locationNameList"); listName == "" {+ prefix += ".member"+ } else {+ prefix += "." + listName+ }+ }++ for i := 0; i < value.Len(); i++ {+ slicePrefix := prefix+ if slicePrefix == "" {+ slicePrefix = strconv.Itoa(i + 1)+ } else {+ slicePrefix = slicePrefix + "." + strconv.Itoa(i+1)+ }+ if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil {+ return err+ }+ }+ return nil+}++func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {+ // If it's empty, generate an empty value+ if !value.IsNil() && value.Len() == 0 {+ v.Set(prefix, "")+ return nil+ }++ // check for unflattened list member+ if !q.isEC2 && tag.Get("flattened") == "" {+ prefix += ".entry"+ }++ // sort keys for improved serialization consistency.+ // this is not strictly necessary for protocol support.+ mapKeyValues := value.MapKeys()+ mapKeys := map[string]reflect.Value{}+ mapKeyNames := make([]string, len(mapKeyValues))+ for i, mapKey := range mapKeyValues {+ name := mapKey.String()+ mapKeys[name] = mapKey+ mapKeyNames[i] = name+ }+ sort.Strings(mapKeyNames)++ for i, mapKeyName := range mapKeyNames {+ mapKey := mapKeys[mapKeyName]+ mapValue := value.MapIndex(mapKey)++ kname := tag.Get("locationNameKey")+ if kname == "" {+ kname = "key"+ }+ vname := tag.Get("locationNameValue")+ if vname == "" {+ vname = "value"+ }++ // serialize key+ var keyName string+ if prefix == "" {+ keyName = strconv.Itoa(i+1) + "." + kname+ } else {+ keyName = prefix + "." + strconv.Itoa(i+1) + "." + kname+ }++ if err := q.parseValue(v, mapKey, keyName, ""); err != nil {+ return err+ }++ // serialize value+ var valueName string+ if prefix == "" {+ valueName = strconv.Itoa(i+1) + "." + vname+ } else {+ valueName = prefix + "." + strconv.Itoa(i+1) + "." + vname+ }++ if err := q.parseValue(v, mapValue, valueName, ""); err != nil {+ return err+ }+ }++ return nil+}++func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {+ switch value := r.Interface().(type) {+ case string:+ v.Set(name, value)+ case []byte:+ if !r.IsNil() {+ v.Set(name, base64.StdEncoding.EncodeToString(value))+ }+ case bool:+ v.Set(name, strconv.FormatBool(value))+ case int64:+ v.Set(name, strconv.FormatInt(value, 10))+ case int:+ v.Set(name, strconv.Itoa(value))+ case float64:+ v.Set(name, strconv.FormatFloat(value, 'f', -1, 64))+ case float32:+ v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32))+ case time.Time:+ const ISO8601UTC = "2006-01-02T15:04:05Z"+ format := tag.Get("timestampFormat")+ if len(format) == 0 {+ format = protocol.ISO8601TimeFormatName+ }++ v.Set(name, protocol.FormatTime(format, value))+ default:+ return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())+ }+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.gonew file mode 100644index 000000000..3495c7307--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go@@ -0,0 +1,39 @@+package query++//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/query.json unmarshal_test.go++import (+ "encoding/xml"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"+)++// UnmarshalHandler is a named request handler for unmarshaling query protocol requests+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.query.Unmarshal", Fn: Unmarshal}++// UnmarshalMetaHandler is a named request handler for unmarshaling query protocol request metadata+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalMeta", Fn: UnmarshalMeta}++// Unmarshal unmarshals a response for an AWS Query service.+func Unmarshal(r *request.Request) {+ defer r.HTTPResponse.Body.Close()+ if r.DataFilled() {+ decoder := xml.NewDecoder(r.HTTPResponse.Body)+ err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")+ if err != nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError", "failed decoding Query response", err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }+ }+}++// UnmarshalMeta unmarshals header response values for an AWS Query service.+func UnmarshalMeta(r *request.Request) {+ r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid")+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.gonew file mode 100644index 000000000..46d354e82--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go@@ -0,0 +1,74 @@+package query++import (+ "encoding/xml"+ "io/ioutil"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++type xmlErrorResponse struct {+ XMLName xml.Name `xml:"ErrorResponse"`+ Code string `xml:"Error>Code"`+ Message string `xml:"Error>Message"`+ RequestID string `xml:"RequestId"`+}++type xmlServiceUnavailableResponse struct {+ XMLName xml.Name `xml:"ServiceUnavailableException"`+}++// UnmarshalErrorHandler is a name request handler to unmarshal request errors+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalError", Fn: UnmarshalError}++// UnmarshalError unmarshals an error response for an AWS Query service.+func UnmarshalError(r *request.Request) {+ defer r.HTTPResponse.Body.Close()++ bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError", "failed to read from query HTTP response body", err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }++ // First check for specific error+ resp := xmlErrorResponse{}+ decodeErr := xml.Unmarshal(bodyBytes, &resp)+ if decodeErr == nil {+ reqID := resp.RequestID+ if reqID == "" {+ reqID = r.RequestID+ }+ r.Error = awserr.NewRequestFailure(+ awserr.New(resp.Code, resp.Message, nil),+ r.HTTPResponse.StatusCode,+ reqID,+ )+ return+ }++ // Check for unhandled error+ servUnavailResp := xmlServiceUnavailableResponse{}+ unavailErr := xml.Unmarshal(bodyBytes, &servUnavailResp)+ if unavailErr == nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("ServiceUnavailableException", "service is unavailable", nil),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }++ // Failed to retrieve any error message from the response body+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError",+ "failed to decode query XML error response", decodeErr),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.gonew file mode 100644index 000000000..b34f5258a--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go@@ -0,0 +1,295 @@+// Package rest provides RESTful serialization of AWS requests and responses.+package rest++import (+ "bytes"+ "encoding/base64"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "path"+ "reflect"+ "strconv"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol"+)++// Whether the byte value can be sent without escaping in AWS URLs+var noEscape [256]bool++var errValueNotSet = fmt.Errorf("value not set")++func init() {+ for i := 0; i < len(noEscape); i++ {+ // AWS expects every character except these to be escaped+ noEscape[i] = (i >= 'A' && i <= 'Z') ||+ (i >= 'a' && i <= 'z') ||+ (i >= '0' && i <= '9') ||+ i == '-' ||+ i == '.' ||+ i == '_' ||+ i == '~'+ }+}++// BuildHandler is a named request handler for building rest protocol requests+var BuildHandler = request.NamedHandler{Name: "awssdk.rest.Build", Fn: Build}++// Build builds the REST component of a service request.+func Build(r *request.Request) {+ if r.ParamsFilled() {+ v := reflect.ValueOf(r.Params).Elem()+ buildLocationElements(r, v, false)+ buildBody(r, v)+ }+}++// BuildAsGET builds the REST component of a service request with the ability to hoist+// data from the body.+func BuildAsGET(r *request.Request) {+ if r.ParamsFilled() {+ v := reflect.ValueOf(r.Params).Elem()+ buildLocationElements(r, v, true)+ buildBody(r, v)+ }+}++func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bool) {+ query := r.HTTPRequest.URL.Query()++ // Setup the raw path to match the base path pattern. This is needed+ // so that when the path is mutated a custom escaped version can be+ // stored in RawPath that will be used by the Go client.+ r.HTTPRequest.URL.RawPath = r.HTTPRequest.URL.Path++ for i := 0; i < v.NumField(); i++ {+ m := v.Field(i)+ if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {+ continue+ }++ if m.IsValid() {+ field := v.Type().Field(i)+ name := field.Tag.Get("locationName")+ if name == "" {+ name = field.Name+ }+ if kind := m.Kind(); kind == reflect.Ptr {+ m = m.Elem()+ } else if kind == reflect.Interface {+ if !m.Elem().IsValid() {+ continue+ }+ }+ if !m.IsValid() {+ continue+ }+ if field.Tag.Get("ignore") != "" {+ continue+ }++ var err error+ switch field.Tag.Get("location") {+ case "headers": // header maps+ err = buildHeaderMap(&r.HTTPRequest.Header, m, field.Tag)+ case "header":+ err = buildHeader(&r.HTTPRequest.Header, m, name, field.Tag)+ case "uri":+ err = buildURI(r.HTTPRequest.URL, m, name, field.Tag)+ case "querystring":+ err = buildQueryString(query, m, name, field.Tag)+ default:+ if buildGETQuery {+ err = buildQueryString(query, m, name, field.Tag)+ }+ }+ r.Error = err+ }+ if r.Error != nil {+ return+ }+ }++ r.HTTPRequest.URL.RawQuery = query.Encode()+ if !aws.BoolValue(r.Config.DisableRestProtocolURICleaning) {+ cleanPath(r.HTTPRequest.URL)+ }+}++func buildBody(r *request.Request, v reflect.Value) {+ if field, ok := v.Type().FieldByName("_"); ok {+ if payloadName := field.Tag.Get("payload"); payloadName != "" {+ pfield, _ := v.Type().FieldByName(payloadName)+ if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {+ payload := reflect.Indirect(v.FieldByName(payloadName))+ if payload.IsValid() && payload.Interface() != nil {+ switch reader := payload.Interface().(type) {+ case io.ReadSeeker:+ r.SetReaderBody(reader)+ case []byte:+ r.SetBufferBody(reader)+ case string:+ r.SetStringBody(reader)+ default:+ r.Error = awserr.New("SerializationError",+ "failed to encode REST request",+ fmt.Errorf("unknown payload type %s", payload.Type()))+ }+ }+ }+ }+ }+}++func buildHeader(header *http.Header, v reflect.Value, name string, tag reflect.StructTag) error {+ str, err := convertType(v, tag)+ if err == errValueNotSet {+ return nil+ } else if err != nil {+ return awserr.New("SerializationError", "failed to encode REST request", err)+ }++ header.Add(name, str)++ return nil+}++func buildHeaderMap(header *http.Header, v reflect.Value, tag reflect.StructTag) error {+ prefix := tag.Get("locationName")+ for _, key := range v.MapKeys() {+ str, err := convertType(v.MapIndex(key), tag)+ if err == errValueNotSet {+ continue+ } else if err != nil {+ return awserr.New("SerializationError", "failed to encode REST request", err)++ }++ header.Add(prefix+key.String(), str)+ }+ return nil+}++func buildURI(u *url.URL, v reflect.Value, name string, tag reflect.StructTag) error {+ value, err := convertType(v, tag)+ if err == errValueNotSet {+ return nil+ } else if err != nil {+ return awserr.New("SerializationError", "failed to encode REST request", err)+ }++ u.Path = strings.Replace(u.Path, "{"+name+"}", value, -1)+ u.Path = strings.Replace(u.Path, "{"+name+"+}", value, -1)++ u.RawPath = strings.Replace(u.RawPath, "{"+name+"}", EscapePath(value, true), -1)+ u.RawPath = strings.Replace(u.RawPath, "{"+name+"+}", EscapePath(value, false), -1)++ return nil+}++func buildQueryString(query url.Values, v reflect.Value, name string, tag reflect.StructTag) error {+ switch value := v.Interface().(type) {+ case []*string:+ for _, item := range value {+ query.Add(name, *item)+ }+ case map[string]*string:+ for key, item := range value {+ query.Add(key, *item)+ }+ case map[string][]*string:+ for key, items := range value {+ for _, item := range items {+ query.Add(key, *item)+ }+ }+ default:+ str, err := convertType(v, tag)+ if err == errValueNotSet {+ return nil+ } else if err != nil {+ return awserr.New("SerializationError", "failed to encode REST request", err)+ }+ query.Set(name, str)+ }++ return nil+}++func cleanPath(u *url.URL) {+ hasSlash := strings.HasSuffix(u.Path, "/")++ // clean up path, removing duplicate `/`+ u.Path = path.Clean(u.Path)+ u.RawPath = path.Clean(u.RawPath)++ if hasSlash && !strings.HasSuffix(u.Path, "/") {+ u.Path += "/"+ u.RawPath += "/"+ }+}++// EscapePath escapes part of a URL path in Amazon style+func EscapePath(path string, encodeSep bool) string {+ var buf bytes.Buffer+ for i := 0; i < len(path); i++ {+ c := path[i]+ if noEscape[c] || (c == '/' && !encodeSep) {+ buf.WriteByte(c)+ } else {+ fmt.Fprintf(&buf, "%%%02X", c)+ }+ }+ return buf.String()+}++func convertType(v reflect.Value, tag reflect.StructTag) (str string, err error) {+ v = reflect.Indirect(v)+ if !v.IsValid() {+ return "", errValueNotSet+ }++ switch value := v.Interface().(type) {+ case string:+ str = value+ case []byte:+ str = base64.StdEncoding.EncodeToString(value)+ case bool:+ str = strconv.FormatBool(value)+ case int64:+ str = strconv.FormatInt(value, 10)+ case float64:+ str = strconv.FormatFloat(value, 'f', -1, 64)+ case time.Time:+ format := tag.Get("timestampFormat")+ if len(format) == 0 {+ format = protocol.RFC822TimeFormatName+ if tag.Get("location") == "querystring" {+ format = protocol.ISO8601TimeFormatName+ }+ }+ str = protocol.FormatTime(format, value)+ case aws.JSONValue:+ if len(value) == 0 {+ return "", errValueNotSet+ }+ escaping := protocol.NoEscape+ if tag.Get("location") == "header" {+ escaping = protocol.Base64Escape+ }+ str, err = protocol.EncodeJSONValue(value, escaping)+ if err != nil {+ return "", fmt.Errorf("unable to encode JSONValue, %v", err)+ }+ default:+ err := fmt.Errorf("unsupported value for param %v (%s)", v.Interface(), v.Type())+ return "", err+ }+ return str, nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.gonew file mode 100644index 000000000..4366de2e1--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/payload.go@@ -0,0 +1,45 @@+package rest++import "reflect"++// PayloadMember returns the payload field member of i if there is one, or nil.+func PayloadMember(i interface{}) interface{} {+ if i == nil {+ return nil+ }++ v := reflect.ValueOf(i).Elem()+ if !v.IsValid() {+ return nil+ }+ if field, ok := v.Type().FieldByName("_"); ok {+ if payloadName := field.Tag.Get("payload"); payloadName != "" {+ field, _ := v.Type().FieldByName(payloadName)+ if field.Tag.Get("type") != "structure" {+ return nil+ }++ payload := v.FieldByName(payloadName)+ if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {+ return payload.Interface()+ }+ }+ }+ return nil+}++// PayloadType returns the type of a payload field member of i if there is one, or "".+func PayloadType(i interface{}) string {+ v := reflect.Indirect(reflect.ValueOf(i))+ if !v.IsValid() {+ return ""+ }+ if field, ok := v.Type().FieldByName("_"); ok {+ if payloadName := field.Tag.Get("payload"); payloadName != "" {+ if member, ok := v.Type().FieldByName(payloadName); ok {+ return member.Tag.Get("type")+ }+ }+ }+ return ""+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.gonew file mode 100644index 000000000..33fd53b12--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go@@ -0,0 +1,225 @@+package rest++import (+ "bytes"+ "encoding/base64"+ "fmt"+ "io"+ "io/ioutil"+ "net/http"+ "reflect"+ "strconv"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol"+)++// UnmarshalHandler is a named request handler for unmarshaling rest protocol requests+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.rest.Unmarshal", Fn: Unmarshal}++// UnmarshalMetaHandler is a named request handler for unmarshaling rest protocol request metadata+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.rest.UnmarshalMeta", Fn: UnmarshalMeta}++// Unmarshal unmarshals the REST component of a response in a REST service.+func Unmarshal(r *request.Request) {+ if r.DataFilled() {+ v := reflect.Indirect(reflect.ValueOf(r.Data))+ unmarshalBody(r, v)+ }+}++// UnmarshalMeta unmarshals the REST metadata of a response in a REST service+func UnmarshalMeta(r *request.Request) {+ r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid")+ if r.RequestID == "" {+ // Alternative version of request id in the header+ r.RequestID = r.HTTPResponse.Header.Get("X-Amz-Request-Id")+ }+ if r.DataFilled() {+ v := reflect.Indirect(reflect.ValueOf(r.Data))+ unmarshalLocationElements(r, v)+ }+}++func unmarshalBody(r *request.Request, v reflect.Value) {+ if field, ok := v.Type().FieldByName("_"); ok {+ if payloadName := field.Tag.Get("payload"); payloadName != "" {+ pfield, _ := v.Type().FieldByName(payloadName)+ if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {+ payload := v.FieldByName(payloadName)+ if payload.IsValid() {+ switch payload.Interface().(type) {+ case []byte:+ defer r.HTTPResponse.Body.Close()+ b, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.New("SerializationError", "failed to decode REST response", err)+ } else {+ payload.Set(reflect.ValueOf(b))+ }+ case *string:+ defer r.HTTPResponse.Body.Close()+ b, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.New("SerializationError", "failed to decode REST response", err)+ } else {+ str := string(b)+ payload.Set(reflect.ValueOf(&str))+ }+ default:+ switch payload.Type().String() {+ case "io.ReadCloser":+ payload.Set(reflect.ValueOf(r.HTTPResponse.Body))+ case "io.ReadSeeker":+ b, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.New("SerializationError",+ "failed to read response body", err)+ return+ }+ payload.Set(reflect.ValueOf(ioutil.NopCloser(bytes.NewReader(b))))+ default:+ io.Copy(ioutil.Discard, r.HTTPResponse.Body)+ defer r.HTTPResponse.Body.Close()+ r.Error = awserr.New("SerializationError",+ "failed to decode REST response",+ fmt.Errorf("unknown payload type %s", payload.Type()))+ }+ }+ }+ }+ }+ }+}++func unmarshalLocationElements(r *request.Request, v reflect.Value) {+ for i := 0; i < v.NumField(); i++ {+ m, field := v.Field(i), v.Type().Field(i)+ if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) {+ continue+ }++ if m.IsValid() {+ name := field.Tag.Get("locationName")+ if name == "" {+ name = field.Name+ }++ switch field.Tag.Get("location") {+ case "statusCode":+ unmarshalStatusCode(m, r.HTTPResponse.StatusCode)+ case "header":+ err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name), field.Tag)+ if err != nil {+ r.Error = awserr.New("SerializationError", "failed to decode REST response", err)+ break+ }+ case "headers":+ prefix := field.Tag.Get("locationName")+ err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)+ if err != nil {+ r.Error = awserr.New("SerializationError", "failed to decode REST response", err)+ break+ }+ }+ }+ if r.Error != nil {+ return+ }+ }+}++func unmarshalStatusCode(v reflect.Value, statusCode int) {+ if !v.IsValid() {+ return+ }++ switch v.Interface().(type) {+ case *int64:+ s := int64(statusCode)+ v.Set(reflect.ValueOf(&s))+ }+}++func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) error {+ switch r.Interface().(type) {+ case map[string]*string: // we only support string map value types+ out := map[string]*string{}+ for k, v := range headers {+ k = http.CanonicalHeaderKey(k)+ if strings.HasPrefix(strings.ToLower(k), strings.ToLower(prefix)) {+ out[k[len(prefix):]] = &v[0]+ }+ }+ r.Set(reflect.ValueOf(out))+ }+ return nil+}++func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) error {+ isJSONValue := tag.Get("type") == "jsonvalue"+ if isJSONValue {+ if len(header) == 0 {+ return nil+ }+ } else if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {+ return nil+ }++ switch v.Interface().(type) {+ case *string:+ v.Set(reflect.ValueOf(&header))+ case []byte:+ b, err := base64.StdEncoding.DecodeString(header)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(&b))+ case *bool:+ b, err := strconv.ParseBool(header)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(&b))+ case *int64:+ i, err := strconv.ParseInt(header, 10, 64)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(&i))+ case *float64:+ f, err := strconv.ParseFloat(header, 64)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(&f))+ case *time.Time:+ format := tag.Get("timestampFormat")+ if len(format) == 0 {+ format = protocol.RFC822TimeFormatName+ }+ t, err := protocol.ParseTime(format, header)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(&t))+ case aws.JSONValue:+ escaping := protocol.NoEscape+ if tag.Get("location") == "header" {+ escaping = protocol.Base64Escape+ }+ m, err := protocol.DecodeJSONValue(header, escaping)+ if err != nil {+ return err+ }+ v.Set(reflect.ValueOf(m))+ default:+ err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())+ return err+ }+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.gonew file mode 100644index 000000000..b0f4e2456--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go@@ -0,0 +1,77 @@+// Package restxml provides RESTful XML serialization of AWS+// requests and responses.+package restxml++//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/rest-xml.json build_test.go+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/rest-xml.json unmarshal_test.go++import (+ "bytes"+ "encoding/xml"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol/query"+ "github.com/aws/aws-sdk-go/private/protocol/rest"+ "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"+)++// BuildHandler is a named request handler for building restxml protocol requests+var BuildHandler = request.NamedHandler{Name: "awssdk.restxml.Build", Fn: Build}++// UnmarshalHandler is a named request handler for unmarshaling restxml protocol requests+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restxml.Unmarshal", Fn: Unmarshal}++// UnmarshalMetaHandler is a named request handler for unmarshaling restxml protocol request metadata+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalMeta", Fn: UnmarshalMeta}++// UnmarshalErrorHandler is a named request handler for unmarshaling restxml protocol request errors+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalError", Fn: UnmarshalError}++// Build builds a request payload for the REST XML protocol.+func Build(r *request.Request) {+ rest.Build(r)++ if t := rest.PayloadType(r.Params); t == "structure" || t == "" {+ var buf bytes.Buffer+ err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf))+ if err != nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError", "failed to encode rest XML request", err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }+ r.SetBufferBody(buf.Bytes())+ }+}++// Unmarshal unmarshals a payload response for the REST XML protocol.+func Unmarshal(r *request.Request) {+ if t := rest.PayloadType(r.Data); t == "structure" || t == "" {+ defer r.HTTPResponse.Body.Close()+ decoder := xml.NewDecoder(r.HTTPResponse.Body)+ err := xmlutil.UnmarshalXML(r.Data, decoder, "")+ if err != nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError", "failed to decode REST XML response", err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }+ } else {+ rest.Unmarshal(r)+ }+}++// UnmarshalMeta unmarshals response headers for the REST XML protocol.+func UnmarshalMeta(r *request.Request) {+ rest.UnmarshalMeta(r)+}++// UnmarshalError unmarshals a response error for the REST XML protocol.+func UnmarshalError(r *request.Request) {+ query.UnmarshalError(r)+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/timestamp.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/timestamp.gonew file mode 100644index 000000000..b7ed6c6f8--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/timestamp.go@@ -0,0 +1,72 @@+package protocol++import (+ "strconv"+ "time"+)++// Names of time formats supported by the SDK+const (+ RFC822TimeFormatName = "rfc822"+ ISO8601TimeFormatName = "iso8601"+ UnixTimeFormatName = "unixTimestamp"+)++// Time formats supported by the SDK+const (+ // RFC 7231#section-7.1.1.1 timetamp format. e.g Tue, 29 Apr 2014 18:30:38 GMT+ RFC822TimeFormat = "Mon, 2 Jan 2006 15:04:05 GMT"++ // RFC3339 a subset of the ISO8601 timestamp format. e.g 2014-04-29T18:30:38Z+ ISO8601TimeFormat = "2006-01-02T15:04:05Z"+)++// IsKnownTimestampFormat returns if the timestamp format name+// is know to the SDK's protocols.+func IsKnownTimestampFormat(name string) bool {+ switch name {+ case RFC822TimeFormatName:+ fallthrough+ case ISO8601TimeFormatName:+ fallthrough+ case UnixTimeFormatName:+ return true+ default:+ return false+ }+}++// FormatTime returns a string value of the time.+func FormatTime(name string, t time.Time) string {+ t = t.UTC()++ switch name {+ case RFC822TimeFormatName:+ return t.Format(RFC822TimeFormat)+ case ISO8601TimeFormatName:+ return t.Format(ISO8601TimeFormat)+ case UnixTimeFormatName:+ return strconv.FormatInt(t.Unix(), 10)+ default:+ panic("unknown timestamp format name, " + name)+ }+}++// ParseTime attempts to parse the time given the format. Returns+// the time if it was able to be parsed, and fails otherwise.+func ParseTime(formatName, value string) (time.Time, error) {+ switch formatName {+ case RFC822TimeFormatName:+ return time.Parse(RFC822TimeFormat, value)+ case ISO8601TimeFormatName:+ return time.Parse(ISO8601TimeFormat, value)+ case UnixTimeFormatName:+ v, err := strconv.ParseFloat(value, 64)+ if err != nil {+ return time.Time{}, err+ }+ return time.Unix(int64(v), 0), nil+ default:+ panic("unknown timestamp format name, " + formatName)+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.gonew file mode 100644index 000000000..da1a68111--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go@@ -0,0 +1,21 @@+package protocol++import (+ "io"+ "io/ioutil"++ "github.com/aws/aws-sdk-go/aws/request"+)++// UnmarshalDiscardBodyHandler is a named request handler to empty and close a response's body+var UnmarshalDiscardBodyHandler = request.NamedHandler{Name: "awssdk.shared.UnmarshalDiscardBody", Fn: UnmarshalDiscardBody}++// UnmarshalDiscardBody is a request handler to empty a response's body and closing it.+func UnmarshalDiscardBody(r *request.Request) {+ if r.HTTPResponse == nil || r.HTTPResponse.Body == nil {+ return+ }++ io.Copy(ioutil.Discard, r.HTTPResponse.Body)+ r.HTTPResponse.Body.Close()+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.gonew file mode 100644index 000000000..cf981fe95--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go@@ -0,0 +1,306 @@+// Package xmlutil provides XML serialization of AWS requests and responses.+package xmlutil++import (+ "encoding/base64"+ "encoding/xml"+ "fmt"+ "reflect"+ "sort"+ "strconv"+ "time"++ "github.com/aws/aws-sdk-go/private/protocol"+)++// BuildXML will serialize params into an xml.Encoder. Error will be returned+// if the serialization of any of the params or nested values fails.+func BuildXML(params interface{}, e *xml.Encoder) error {+ return buildXML(params, e, false)+}++func buildXML(params interface{}, e *xml.Encoder, sorted bool) error {+ b := xmlBuilder{encoder: e, namespaces: map[string]string{}}+ root := NewXMLElement(xml.Name{})+ if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {+ return err+ }+ for _, c := range root.Children {+ for _, v := range c {+ return StructToXML(e, v, sorted)+ }+ }+ return nil+}++// Returns the reflection element of a value, if it is a pointer.+func elemOf(value reflect.Value) reflect.Value {+ for value.Kind() == reflect.Ptr {+ value = value.Elem()+ }+ return value+}++// A xmlBuilder serializes values from Go code to XML+type xmlBuilder struct {+ encoder *xml.Encoder+ namespaces map[string]string+}++// buildValue generic XMLNode builder for any type. Will build value for their specific type+// struct, list, map, scalar.+//+// Also takes a "type" tag value to set what type a value should be converted to XMLNode as. If+// type is not provided reflect will be used to determine the value's type.+func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {+ value = elemOf(value)+ if !value.IsValid() { // no need to handle zero values+ return nil+ } else if tag.Get("location") != "" { // don't handle non-body location values+ return nil+ }++ t := tag.Get("type")+ if t == "" {+ switch value.Kind() {+ case reflect.Struct:+ t = "structure"+ case reflect.Slice:+ t = "list"+ case reflect.Map:+ t = "map"+ }+ }++ switch t {+ case "structure":+ if field, ok := value.Type().FieldByName("_"); ok {+ tag = tag + reflect.StructTag(" ") + field.Tag+ }+ return b.buildStruct(value, current, tag)+ case "list":+ return b.buildList(value, current, tag)+ case "map":+ return b.buildMap(value, current, tag)+ default:+ return b.buildScalar(value, current, tag)+ }+}++// buildStruct adds a struct and its fields to the current XMLNode. All fields and any nested+// types are converted to XMLNodes also.+func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {+ if !value.IsValid() {+ return nil+ }++ // unwrap payloads+ if payload := tag.Get("payload"); payload != "" {+ field, _ := value.Type().FieldByName(payload)+ tag = field.Tag+ value = elemOf(value.FieldByName(payload))++ if !value.IsValid() {+ return nil+ }+ }++ child := NewXMLElement(xml.Name{Local: tag.Get("locationName")})++ // there is an xmlNamespace associated with this struct+ if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" {+ ns := xml.Attr{+ Name: xml.Name{Local: "xmlns"},+ Value: uri,+ }+ if prefix != "" {+ b.namespaces[prefix] = uri // register the namespace+ ns.Name.Local = "xmlns:" + prefix+ }++ child.Attr = append(child.Attr, ns)+ }++ var payloadFields, nonPayloadFields int++ t := value.Type()+ for i := 0; i < value.NumField(); i++ {+ member := elemOf(value.Field(i))+ field := t.Field(i)++ if field.PkgPath != "" {+ continue // ignore unexported fields+ }+ if field.Tag.Get("ignore") != "" {+ continue+ }++ mTag := field.Tag+ if mTag.Get("location") != "" { // skip non-body members+ nonPayloadFields+++ continue+ }+ payloadFields++++ if protocol.CanSetIdempotencyToken(value.Field(i), field) {+ token := protocol.GetIdempotencyToken()+ member = reflect.ValueOf(token)+ }++ memberName := mTag.Get("locationName")+ if memberName == "" {+ memberName = field.Name+ mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`)+ }+ if err := b.buildValue(member, child, mTag); err != nil {+ return err+ }+ }++ // Only case where the child shape is not added is if the shape only contains+ // non-payload fields, e.g headers/query.+ if !(payloadFields == 0 && nonPayloadFields > 0) {+ current.AddChild(child)+ }++ return nil+}++// buildList adds the value's list items to the current XMLNode as children nodes. All+// nested values in the list are converted to XMLNodes also.+func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {+ if value.IsNil() { // don't build omitted lists+ return nil+ }++ // check for unflattened list member+ flattened := tag.Get("flattened") != ""++ xname := xml.Name{Local: tag.Get("locationName")}+ if flattened {+ for i := 0; i < value.Len(); i++ {+ child := NewXMLElement(xname)+ current.AddChild(child)+ if err := b.buildValue(value.Index(i), child, ""); err != nil {+ return err+ }+ }+ } else {+ list := NewXMLElement(xname)+ current.AddChild(list)++ for i := 0; i < value.Len(); i++ {+ iname := tag.Get("locationNameList")+ if iname == "" {+ iname = "member"+ }++ child := NewXMLElement(xml.Name{Local: iname})+ list.AddChild(child)+ if err := b.buildValue(value.Index(i), child, ""); err != nil {+ return err+ }+ }+ }++ return nil+}++// buildMap adds the value's key/value pairs to the current XMLNode as children nodes. All+// nested values in the map are converted to XMLNodes also.+//+// Error will be returned if it is unable to build the map's values into XMLNodes+func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {+ if value.IsNil() { // don't build omitted maps+ return nil+ }++ maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")})+ current.AddChild(maproot)+ current = maproot++ kname, vname := "key", "value"+ if n := tag.Get("locationNameKey"); n != "" {+ kname = n+ }+ if n := tag.Get("locationNameValue"); n != "" {+ vname = n+ }++ // sorting is not required for compliance, but it makes testing easier+ keys := make([]string, value.Len())+ for i, k := range value.MapKeys() {+ keys[i] = k.String()+ }+ sort.Strings(keys)++ for _, k := range keys {+ v := value.MapIndex(reflect.ValueOf(k))++ mapcur := current+ if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps+ child := NewXMLElement(xml.Name{Local: "entry"})+ mapcur.AddChild(child)+ mapcur = child+ }++ kchild := NewXMLElement(xml.Name{Local: kname})+ kchild.Text = k+ vchild := NewXMLElement(xml.Name{Local: vname})+ mapcur.AddChild(kchild)+ mapcur.AddChild(vchild)++ if err := b.buildValue(v, vchild, ""); err != nil {+ return err+ }+ }++ return nil+}++// buildScalar will convert the value into a string and append it as a attribute or child+// of the current XMLNode.+//+// The value will be added as an attribute if tag contains a "xmlAttribute" attribute value.+//+// Error will be returned if the value type is unsupported.+func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {+ var str string+ switch converted := value.Interface().(type) {+ case string:+ str = converted+ case []byte:+ if !value.IsNil() {+ str = base64.StdEncoding.EncodeToString(converted)+ }+ case bool:+ str = strconv.FormatBool(converted)+ case int64:+ str = strconv.FormatInt(converted, 10)+ case int:+ str = strconv.Itoa(converted)+ case float64:+ str = strconv.FormatFloat(converted, 'f', -1, 64)+ case float32:+ str = strconv.FormatFloat(float64(converted), 'f', -1, 32)+ case time.Time:+ format := tag.Get("timestampFormat")+ if len(format) == 0 {+ format = protocol.ISO8601TimeFormatName+ }++ str = protocol.FormatTime(format, converted)+ default:+ return fmt.Errorf("unsupported value for param %s: %v (%s)",+ tag.Get("locationName"), value.Interface(), value.Type().Name())+ }++ xname := xml.Name{Local: tag.Get("locationName")}+ if tag.Get("xmlAttribute") != "" { // put into current node's attribute list+ attr := xml.Attr{Name: xname, Value: str}+ current.Attr = append(current.Attr, attr)+ } else { // regular text node+ current.AddChild(&XMLNode{Name: xname, Text: str})+ }+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.gonew file mode 100644index 000000000..ff1ef6830--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go@@ -0,0 +1,272 @@+package xmlutil++import (+ "encoding/base64"+ "encoding/xml"+ "fmt"+ "io"+ "reflect"+ "strconv"+ "strings"+ "time"++ "github.com/aws/aws-sdk-go/private/protocol"+)++// UnmarshalXML deserializes an xml.Decoder into the container v. V+// needs to match the shape of the XML expected to be decoded.+// If the shape doesn't match unmarshaling will fail.+func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {+ n, err := XMLToStruct(d, nil)+ if err != nil {+ return err+ }+ if n.Children != nil {+ for _, root := range n.Children {+ for _, c := range root {+ if wrappedChild, ok := c.Children[wrapper]; ok {+ c = wrappedChild[0] // pull out wrapped element+ }++ err = parse(reflect.ValueOf(v), c, "")+ if err != nil {+ if err == io.EOF {+ return nil+ }+ return err+ }+ }+ }+ return nil+ }+ return nil+}++// parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect+// will be used to determine the type from r.+func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ rtype := r.Type()+ if rtype.Kind() == reflect.Ptr {+ rtype = rtype.Elem() // check kind of actual element type+ }++ t := tag.Get("type")+ if t == "" {+ switch rtype.Kind() {+ case reflect.Struct:+ // also it can't be a time object+ if _, ok := r.Interface().(*time.Time); !ok {+ t = "structure"+ }+ case reflect.Slice:+ // also it can't be a byte slice+ if _, ok := r.Interface().([]byte); !ok {+ t = "list"+ }+ case reflect.Map:+ t = "map"+ }+ }++ switch t {+ case "structure":+ if field, ok := rtype.FieldByName("_"); ok {+ tag = field.Tag+ }+ return parseStruct(r, node, tag)+ case "list":+ return parseList(r, node, tag)+ case "map":+ return parseMap(r, node, tag)+ default:+ return parseScalar(r, node, tag)+ }+}++// parseStruct deserializes a structure and its fields from an XMLNode. Any nested+// types in the structure will also be deserialized.+func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ t := r.Type()+ if r.Kind() == reflect.Ptr {+ if r.IsNil() { // create the structure if it's nil+ s := reflect.New(r.Type().Elem())+ r.Set(s)+ r = s+ }++ r = r.Elem()+ t = t.Elem()+ }++ // unwrap any payloads+ if payload := tag.Get("payload"); payload != "" {+ field, _ := t.FieldByName(payload)+ return parseStruct(r.FieldByName(payload), node, field.Tag)+ }++ for i := 0; i < t.NumField(); i++ {+ field := t.Field(i)+ if c := field.Name[0:1]; strings.ToLower(c) == c {+ continue // ignore unexported fields+ }++ // figure out what this field is called+ name := field.Name+ if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {+ name = field.Tag.Get("locationNameList")+ } else if locName := field.Tag.Get("locationName"); locName != "" {+ name = locName+ }++ // try to find the field by name in elements+ elems := node.Children[name]++ if elems == nil { // try to find the field in attributes+ if val, ok := node.findElem(name); ok {+ elems = []*XMLNode{{Text: val}}+ }+ }++ member := r.FieldByName(field.Name)+ for _, elem := range elems {+ err := parse(member, elem, field.Tag)+ if err != nil {+ return err+ }+ }+ }+ return nil+}++// parseList deserializes a list of values from an XML node. Each list entry+// will also be deserialized.+func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ t := r.Type()++ if tag.Get("flattened") == "" { // look at all item entries+ mname := "member"+ if name := tag.Get("locationNameList"); name != "" {+ mname = name+ }++ if Children, ok := node.Children[mname]; ok {+ if r.IsNil() {+ r.Set(reflect.MakeSlice(t, len(Children), len(Children)))+ }++ for i, c := range Children {+ err := parse(r.Index(i), c, "")+ if err != nil {+ return err+ }+ }+ }+ } else { // flattened list means this is a single element+ if r.IsNil() {+ r.Set(reflect.MakeSlice(t, 0, 0))+ }++ childR := reflect.Zero(t.Elem())+ r.Set(reflect.Append(r, childR))+ err := parse(r.Index(r.Len()-1), node, "")+ if err != nil {+ return err+ }+ }++ return nil+}++// parseMap deserializes a map from an XMLNode. The direct children of the XMLNode+// will also be deserialized as map entries.+func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ if r.IsNil() {+ r.Set(reflect.MakeMap(r.Type()))+ }++ if tag.Get("flattened") == "" { // look at all child entries+ for _, entry := range node.Children["entry"] {+ parseMapEntry(r, entry, tag)+ }+ } else { // this element is itself an entry+ parseMapEntry(r, node, tag)+ }++ return nil+}++// parseMapEntry deserializes a map entry from a XML node.+func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ kname, vname := "key", "value"+ if n := tag.Get("locationNameKey"); n != "" {+ kname = n+ }+ if n := tag.Get("locationNameValue"); n != "" {+ vname = n+ }++ keys, ok := node.Children[kname]+ values := node.Children[vname]+ if ok {+ for i, key := range keys {+ keyR := reflect.ValueOf(key.Text)+ value := values[i]+ valueR := reflect.New(r.Type().Elem()).Elem()++ parse(valueR, value, "")+ r.SetMapIndex(keyR, valueR)+ }+ }+ return nil+}++// parseScaller deserializes an XMLNode value into a concrete type based on the+// interface type of r.+//+// Error is returned if the deserialization fails due to invalid type conversion,+// or unsupported interface type.+func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {+ switch r.Interface().(type) {+ case *string:+ r.Set(reflect.ValueOf(&node.Text))+ return nil+ case []byte:+ b, err := base64.StdEncoding.DecodeString(node.Text)+ if err != nil {+ return err+ }+ r.Set(reflect.ValueOf(b))+ case *bool:+ v, err := strconv.ParseBool(node.Text)+ if err != nil {+ return err+ }+ r.Set(reflect.ValueOf(&v))+ case *int64:+ v, err := strconv.ParseInt(node.Text, 10, 64)+ if err != nil {+ return err+ }+ r.Set(reflect.ValueOf(&v))+ case *float64:+ v, err := strconv.ParseFloat(node.Text, 64)+ if err != nil {+ return err+ }+ r.Set(reflect.ValueOf(&v))+ case *time.Time:+ format := tag.Get("timestampFormat")+ if len(format) == 0 {+ format = protocol.ISO8601TimeFormatName+ }++ t, err := protocol.ParseTime(format, node.Text)+ if err != nil {+ return err+ }+ r.Set(reflect.ValueOf(&t))+ default:+ return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())+ }+ return nil+}diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.gonew file mode 100644index 000000000..515ce1521--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go@@ -0,0 +1,148 @@+package xmlutil++import (+ "encoding/xml"+ "fmt"+ "io"+ "sort"+)++// A XMLNode contains the values to be encoded or decoded.+type XMLNode struct {+ Name xml.Name `json:",omitempty"`+ Children map[string][]*XMLNode `json:",omitempty"`+ Text string `json:",omitempty"`+ Attr []xml.Attr `json:",omitempty"`++ namespaces map[string]string+ parent *XMLNode+}++// NewXMLElement returns a pointer to a new XMLNode initialized to default values.+func NewXMLElement(name xml.Name) *XMLNode {+ return &XMLNode{+ Name: name,+ Children: map[string][]*XMLNode{},+ Attr: []xml.Attr{},+ }+}++// AddChild adds child to the XMLNode.+func (n *XMLNode) AddChild(child *XMLNode) {+ child.parent = n+ if _, ok := n.Children[child.Name.Local]; !ok {+ n.Children[child.Name.Local] = []*XMLNode{}+ }+ n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child)+}++// XMLToStruct converts a xml.Decoder stream to XMLNode with nested values.+func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {+ out := &XMLNode{}+ for {+ tok, err := d.Token()+ if err != nil {+ if err == io.EOF {+ break+ } else {+ return out, err+ }+ }++ if tok == nil {+ break+ }++ switch typed := tok.(type) {+ case xml.CharData:+ out.Text = string(typed.Copy())+ case xml.StartElement:+ el := typed.Copy()+ out.Attr = el.Attr+ if out.Children == nil {+ out.Children = map[string][]*XMLNode{}+ }++ name := typed.Name.Local+ slice := out.Children[name]+ if slice == nil {+ slice = []*XMLNode{}+ }+ node, e := XMLToStruct(d, &el)+ out.findNamespaces()+ if e != nil {+ return out, e+ }+ node.Name = typed.Name+ node.findNamespaces()+ tempOut := *out+ // Save into a temp variable, simply because out gets squashed during+ // loop iterations+ node.parent = &tempOut+ slice = append(slice, node)+ out.Children[name] = slice+ case xml.EndElement:+ if s != nil && s.Name.Local == typed.Name.Local { // matching end token+ return out, nil+ }+ out = &XMLNode{}+ }+ }+ return out, nil+}++func (n *XMLNode) findNamespaces() {+ ns := map[string]string{}+ for _, a := range n.Attr {+ if a.Name.Space == "xmlns" {+ ns[a.Value] = a.Name.Local+ }+ }++ n.namespaces = ns+}++func (n *XMLNode) findElem(name string) (string, bool) {+ for node := n; node != nil; node = node.parent {+ for _, a := range node.Attr {+ namespace := a.Name.Space+ if v, ok := node.namespaces[namespace]; ok {+ namespace = v+ }+ if name == fmt.Sprintf("%s:%s", namespace, a.Name.Local) {+ return a.Value, true+ }+ }+ }+ return "", false+}++// StructToXML writes an XMLNode to a xml.Encoder as tokens.+func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {+ e.EncodeToken(xml.StartElement{Name: node.Name, Attr: node.Attr})++ if node.Text != "" {+ e.EncodeToken(xml.CharData([]byte(node.Text)))+ } else if sorted {+ sortedNames := []string{}+ for k := range node.Children {+ sortedNames = append(sortedNames, k)+ }+ sort.Strings(sortedNames)++ for _, k := range sortedNames {+ for _, v := range node.Children[k] {+ StructToXML(e, v, sorted)+ }+ }+ } else {+ for _, c := range node.Children {+ for _, v := range c {+ StructToXML(e, v, sorted)+ }+ }+ }++ e.EncodeToken(xml.EndElement{Name: node.Name})+ return e.Flush()+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/api.go b/vendor/github.com/aws/aws-sdk-go/service/s3/api.gonew file mode 100644index 000000000..deb8e8964--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/api.go@@ -0,0 +1,24725 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package s3++import (+ "bytes"+ "fmt"+ "io"+ "sync"+ "sync/atomic"+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/awsutil"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/private/protocol"+ "github.com/aws/aws-sdk-go/private/protocol/eventstream"+ "github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi"+ "github.com/aws/aws-sdk-go/private/protocol/rest"+ "github.com/aws/aws-sdk-go/private/protocol/restxml"+)++const opAbortMultipartUpload = "AbortMultipartUpload"++// AbortMultipartUploadRequest generates a "aws/request.Request" representing the+// client's request for the AbortMultipartUpload operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See AbortMultipartUpload for more information on using the AbortMultipartUpload+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the AbortMultipartUploadRequest method.+// req, resp := client.AbortMultipartUploadRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUpload+func (c *S3) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) (req *request.Request, output *AbortMultipartUploadOutput) {+ op := &request.Operation{+ Name: opAbortMultipartUpload,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &AbortMultipartUploadInput{}+ }++ output = &AbortMultipartUploadOutput{}+ req = c.newRequest(op, input, output)+ return+}++// AbortMultipartUpload API operation for Amazon Simple Storage Service.+//+// Aborts a multipart upload.+//+// To verify that all parts have been removed, so you don't get charged for+// the part storage, you should call the List Parts operation and ensure the+// parts list is empty.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation AbortMultipartUpload for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchUpload "NoSuchUpload"+// The specified multipart upload does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortMultipartUpload+func (c *S3) AbortMultipartUpload(input *AbortMultipartUploadInput) (*AbortMultipartUploadOutput, error) {+ req, out := c.AbortMultipartUploadRequest(input)+ return out, req.Send()+}++// AbortMultipartUploadWithContext is the same as AbortMultipartUpload with the addition of+// the ability to pass a context and additional request options.+//+// See AbortMultipartUpload for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) AbortMultipartUploadWithContext(ctx aws.Context, input *AbortMultipartUploadInput, opts ...request.Option) (*AbortMultipartUploadOutput, error) {+ req, out := c.AbortMultipartUploadRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opCompleteMultipartUpload = "CompleteMultipartUpload"++// CompleteMultipartUploadRequest generates a "aws/request.Request" representing the+// client's request for the CompleteMultipartUpload operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See CompleteMultipartUpload for more information on using the CompleteMultipartUpload+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the CompleteMultipartUploadRequest method.+// req, resp := client.CompleteMultipartUploadRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUpload+func (c *S3) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) (req *request.Request, output *CompleteMultipartUploadOutput) {+ op := &request.Operation{+ Name: opCompleteMultipartUpload,+ HTTPMethod: "POST",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &CompleteMultipartUploadInput{}+ }++ output = &CompleteMultipartUploadOutput{}+ req = c.newRequest(op, input, output)+ return+}++// CompleteMultipartUpload API operation for Amazon Simple Storage Service.+//+// Completes a multipart upload by assembling previously uploaded parts.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation CompleteMultipartUpload for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompleteMultipartUpload+func (c *S3) CompleteMultipartUpload(input *CompleteMultipartUploadInput) (*CompleteMultipartUploadOutput, error) {+ req, out := c.CompleteMultipartUploadRequest(input)+ return out, req.Send()+}++// CompleteMultipartUploadWithContext is the same as CompleteMultipartUpload with the addition of+// the ability to pass a context and additional request options.+//+// See CompleteMultipartUpload for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) CompleteMultipartUploadWithContext(ctx aws.Context, input *CompleteMultipartUploadInput, opts ...request.Option) (*CompleteMultipartUploadOutput, error) {+ req, out := c.CompleteMultipartUploadRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opCopyObject = "CopyObject"++// CopyObjectRequest generates a "aws/request.Request" representing the+// client's request for the CopyObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See CopyObject for more information on using the CopyObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the CopyObjectRequest method.+// req, resp := client.CopyObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObject+func (c *S3) CopyObjectRequest(input *CopyObjectInput) (req *request.Request, output *CopyObjectOutput) {+ op := &request.Operation{+ Name: opCopyObject,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &CopyObjectInput{}+ }++ output = &CopyObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// CopyObject API operation for Amazon Simple Storage Service.+//+// Creates a copy of an object that is already stored in Amazon S3.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation CopyObject for usage and error information.+//+// Returned Error Codes:+// * ErrCodeObjectNotInActiveTierError "ObjectNotInActiveTierError"+// The source object of the COPY operation is not in the active tier and is+// only stored in Amazon Glacier.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObject+func (c *S3) CopyObject(input *CopyObjectInput) (*CopyObjectOutput, error) {+ req, out := c.CopyObjectRequest(input)+ return out, req.Send()+}++// CopyObjectWithContext is the same as CopyObject with the addition of+// the ability to pass a context and additional request options.+//+// See CopyObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) CopyObjectWithContext(ctx aws.Context, input *CopyObjectInput, opts ...request.Option) (*CopyObjectOutput, error) {+ req, out := c.CopyObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opCreateBucket = "CreateBucket"++// CreateBucketRequest generates a "aws/request.Request" representing the+// client's request for the CreateBucket operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See CreateBucket for more information on using the CreateBucket+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the CreateBucketRequest method.+// req, resp := client.CreateBucketRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucket+func (c *S3) CreateBucketRequest(input *CreateBucketInput) (req *request.Request, output *CreateBucketOutput) {+ op := &request.Operation{+ Name: opCreateBucket,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}",+ }++ if input == nil {+ input = &CreateBucketInput{}+ }++ output = &CreateBucketOutput{}+ req = c.newRequest(op, input, output)+ return+}++// CreateBucket API operation for Amazon Simple Storage Service.+//+// Creates a new bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation CreateBucket for usage and error information.+//+// Returned Error Codes:+// * ErrCodeBucketAlreadyExists "BucketAlreadyExists"+// The requested bucket name is not available. The bucket namespace is shared+// by all users of the system. Please select a different name and try again.+//+// * ErrCodeBucketAlreadyOwnedByYou "BucketAlreadyOwnedByYou"+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucket+func (c *S3) CreateBucket(input *CreateBucketInput) (*CreateBucketOutput, error) {+ req, out := c.CreateBucketRequest(input)+ return out, req.Send()+}++// CreateBucketWithContext is the same as CreateBucket with the addition of+// the ability to pass a context and additional request options.+//+// See CreateBucket for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) CreateBucketWithContext(ctx aws.Context, input *CreateBucketInput, opts ...request.Option) (*CreateBucketOutput, error) {+ req, out := c.CreateBucketRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opCreateMultipartUpload = "CreateMultipartUpload"++// CreateMultipartUploadRequest generates a "aws/request.Request" representing the+// client's request for the CreateMultipartUpload operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See CreateMultipartUpload for more information on using the CreateMultipartUpload+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the CreateMultipartUploadRequest method.+// req, resp := client.CreateMultipartUploadRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUpload+func (c *S3) CreateMultipartUploadRequest(input *CreateMultipartUploadInput) (req *request.Request, output *CreateMultipartUploadOutput) {+ op := &request.Operation{+ Name: opCreateMultipartUpload,+ HTTPMethod: "POST",+ HTTPPath: "/{Bucket}/{Key+}?uploads",+ }++ if input == nil {+ input = &CreateMultipartUploadInput{}+ }++ output = &CreateMultipartUploadOutput{}+ req = c.newRequest(op, input, output)+ return+}++// CreateMultipartUpload API operation for Amazon Simple Storage Service.+//+// Initiates a multipart upload and returns an upload ID.+//+// Note: After you initiate multipart upload and upload one or more parts, you+// must either complete or abort multipart upload in order to stop getting charged+// for storage of the uploaded parts. Only after you either complete or abort+// multipart upload, Amazon S3 frees up the parts storage and stops charging+// you for the parts storage.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation CreateMultipartUpload for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateMultipartUpload+func (c *S3) CreateMultipartUpload(input *CreateMultipartUploadInput) (*CreateMultipartUploadOutput, error) {+ req, out := c.CreateMultipartUploadRequest(input)+ return out, req.Send()+}++// CreateMultipartUploadWithContext is the same as CreateMultipartUpload with the addition of+// the ability to pass a context and additional request options.+//+// See CreateMultipartUpload for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) CreateMultipartUploadWithContext(ctx aws.Context, input *CreateMultipartUploadInput, opts ...request.Option) (*CreateMultipartUploadOutput, error) {+ req, out := c.CreateMultipartUploadRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucket = "DeleteBucket"++// DeleteBucketRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucket operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucket for more information on using the DeleteBucket+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketRequest method.+// req, resp := client.DeleteBucketRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucket+func (c *S3) DeleteBucketRequest(input *DeleteBucketInput) (req *request.Request, output *DeleteBucketOutput) {+ op := &request.Operation{+ Name: opDeleteBucket,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}",+ }++ if input == nil {+ input = &DeleteBucketInput{}+ }++ output = &DeleteBucketOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucket API operation for Amazon Simple Storage Service.+//+// Deletes the bucket. All objects (including all object versions and Delete+// Markers) in the bucket must be deleted before the bucket itself can be deleted.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucket for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucket+func (c *S3) DeleteBucket(input *DeleteBucketInput) (*DeleteBucketOutput, error) {+ req, out := c.DeleteBucketRequest(input)+ return out, req.Send()+}++// DeleteBucketWithContext is the same as DeleteBucket with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucket for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketWithContext(ctx aws.Context, input *DeleteBucketInput, opts ...request.Option) (*DeleteBucketOutput, error) {+ req, out := c.DeleteBucketRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketAnalyticsConfiguration = "DeleteBucketAnalyticsConfiguration"++// DeleteBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketAnalyticsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketAnalyticsConfiguration for more information on using the DeleteBucketAnalyticsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketAnalyticsConfigurationRequest method.+// req, resp := client.DeleteBucketAnalyticsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfiguration+func (c *S3) DeleteBucketAnalyticsConfigurationRequest(input *DeleteBucketAnalyticsConfigurationInput) (req *request.Request, output *DeleteBucketAnalyticsConfigurationOutput) {+ op := &request.Operation{+ Name: opDeleteBucketAnalyticsConfiguration,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?analytics",+ }++ if input == nil {+ input = &DeleteBucketAnalyticsConfigurationInput{}+ }++ output = &DeleteBucketAnalyticsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.+//+// Deletes an analytics configuration for the bucket (specified by the analytics+// configuration ID).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketAnalyticsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketAnalyticsConfiguration+func (c *S3) DeleteBucketAnalyticsConfiguration(input *DeleteBucketAnalyticsConfigurationInput) (*DeleteBucketAnalyticsConfigurationOutput, error) {+ req, out := c.DeleteBucketAnalyticsConfigurationRequest(input)+ return out, req.Send()+}++// DeleteBucketAnalyticsConfigurationWithContext is the same as DeleteBucketAnalyticsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketAnalyticsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *DeleteBucketAnalyticsConfigurationInput, opts ...request.Option) (*DeleteBucketAnalyticsConfigurationOutput, error) {+ req, out := c.DeleteBucketAnalyticsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketCors = "DeleteBucketCors"++// DeleteBucketCorsRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketCors operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketCors for more information on using the DeleteBucketCors+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketCorsRequest method.+// req, resp := client.DeleteBucketCorsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCors+func (c *S3) DeleteBucketCorsRequest(input *DeleteBucketCorsInput) (req *request.Request, output *DeleteBucketCorsOutput) {+ op := &request.Operation{+ Name: opDeleteBucketCors,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?cors",+ }++ if input == nil {+ input = &DeleteBucketCorsInput{}+ }++ output = &DeleteBucketCorsOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketCors API operation for Amazon Simple Storage Service.+//+// Deletes the CORS configuration information set for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketCors for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketCors+func (c *S3) DeleteBucketCors(input *DeleteBucketCorsInput) (*DeleteBucketCorsOutput, error) {+ req, out := c.DeleteBucketCorsRequest(input)+ return out, req.Send()+}++// DeleteBucketCorsWithContext is the same as DeleteBucketCors with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketCors for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketCorsWithContext(ctx aws.Context, input *DeleteBucketCorsInput, opts ...request.Option) (*DeleteBucketCorsOutput, error) {+ req, out := c.DeleteBucketCorsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketEncryption = "DeleteBucketEncryption"++// DeleteBucketEncryptionRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketEncryption operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketEncryption for more information on using the DeleteBucketEncryption+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketEncryptionRequest method.+// req, resp := client.DeleteBucketEncryptionRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketEncryption+func (c *S3) DeleteBucketEncryptionRequest(input *DeleteBucketEncryptionInput) (req *request.Request, output *DeleteBucketEncryptionOutput) {+ op := &request.Operation{+ Name: opDeleteBucketEncryption,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?encryption",+ }++ if input == nil {+ input = &DeleteBucketEncryptionInput{}+ }++ output = &DeleteBucketEncryptionOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketEncryption API operation for Amazon Simple Storage Service.+//+// Deletes the server-side encryption configuration from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketEncryption for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketEncryption+func (c *S3) DeleteBucketEncryption(input *DeleteBucketEncryptionInput) (*DeleteBucketEncryptionOutput, error) {+ req, out := c.DeleteBucketEncryptionRequest(input)+ return out, req.Send()+}++// DeleteBucketEncryptionWithContext is the same as DeleteBucketEncryption with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketEncryption for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketEncryptionWithContext(ctx aws.Context, input *DeleteBucketEncryptionInput, opts ...request.Option) (*DeleteBucketEncryptionOutput, error) {+ req, out := c.DeleteBucketEncryptionRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketInventoryConfiguration = "DeleteBucketInventoryConfiguration"++// DeleteBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketInventoryConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketInventoryConfiguration for more information on using the DeleteBucketInventoryConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketInventoryConfigurationRequest method.+// req, resp := client.DeleteBucketInventoryConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfiguration+func (c *S3) DeleteBucketInventoryConfigurationRequest(input *DeleteBucketInventoryConfigurationInput) (req *request.Request, output *DeleteBucketInventoryConfigurationOutput) {+ op := &request.Operation{+ Name: opDeleteBucketInventoryConfiguration,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?inventory",+ }++ if input == nil {+ input = &DeleteBucketInventoryConfigurationInput{}+ }++ output = &DeleteBucketInventoryConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketInventoryConfiguration API operation for Amazon Simple Storage Service.+//+// Deletes an inventory configuration (identified by the inventory ID) from+// the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketInventoryConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketInventoryConfiguration+func (c *S3) DeleteBucketInventoryConfiguration(input *DeleteBucketInventoryConfigurationInput) (*DeleteBucketInventoryConfigurationOutput, error) {+ req, out := c.DeleteBucketInventoryConfigurationRequest(input)+ return out, req.Send()+}++// DeleteBucketInventoryConfigurationWithContext is the same as DeleteBucketInventoryConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketInventoryConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketInventoryConfigurationWithContext(ctx aws.Context, input *DeleteBucketInventoryConfigurationInput, opts ...request.Option) (*DeleteBucketInventoryConfigurationOutput, error) {+ req, out := c.DeleteBucketInventoryConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketLifecycle = "DeleteBucketLifecycle"++// DeleteBucketLifecycleRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketLifecycle operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketLifecycle for more information on using the DeleteBucketLifecycle+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketLifecycleRequest method.+// req, resp := client.DeleteBucketLifecycleRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycle+func (c *S3) DeleteBucketLifecycleRequest(input *DeleteBucketLifecycleInput) (req *request.Request, output *DeleteBucketLifecycleOutput) {+ op := &request.Operation{+ Name: opDeleteBucketLifecycle,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?lifecycle",+ }++ if input == nil {+ input = &DeleteBucketLifecycleInput{}+ }++ output = &DeleteBucketLifecycleOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketLifecycle API operation for Amazon Simple Storage Service.+//+// Deletes the lifecycle configuration from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketLifecycle for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketLifecycle+func (c *S3) DeleteBucketLifecycle(input *DeleteBucketLifecycleInput) (*DeleteBucketLifecycleOutput, error) {+ req, out := c.DeleteBucketLifecycleRequest(input)+ return out, req.Send()+}++// DeleteBucketLifecycleWithContext is the same as DeleteBucketLifecycle with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketLifecycle for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketLifecycleWithContext(ctx aws.Context, input *DeleteBucketLifecycleInput, opts ...request.Option) (*DeleteBucketLifecycleOutput, error) {+ req, out := c.DeleteBucketLifecycleRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketMetricsConfiguration = "DeleteBucketMetricsConfiguration"++// DeleteBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketMetricsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketMetricsConfiguration for more information on using the DeleteBucketMetricsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketMetricsConfigurationRequest method.+// req, resp := client.DeleteBucketMetricsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfiguration+func (c *S3) DeleteBucketMetricsConfigurationRequest(input *DeleteBucketMetricsConfigurationInput) (req *request.Request, output *DeleteBucketMetricsConfigurationOutput) {+ op := &request.Operation{+ Name: opDeleteBucketMetricsConfiguration,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?metrics",+ }++ if input == nil {+ input = &DeleteBucketMetricsConfigurationInput{}+ }++ output = &DeleteBucketMetricsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketMetricsConfiguration API operation for Amazon Simple Storage Service.+//+// Deletes a metrics configuration (specified by the metrics configuration ID)+// from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketMetricsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketMetricsConfiguration+func (c *S3) DeleteBucketMetricsConfiguration(input *DeleteBucketMetricsConfigurationInput) (*DeleteBucketMetricsConfigurationOutput, error) {+ req, out := c.DeleteBucketMetricsConfigurationRequest(input)+ return out, req.Send()+}++// DeleteBucketMetricsConfigurationWithContext is the same as DeleteBucketMetricsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketMetricsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketMetricsConfigurationWithContext(ctx aws.Context, input *DeleteBucketMetricsConfigurationInput, opts ...request.Option) (*DeleteBucketMetricsConfigurationOutput, error) {+ req, out := c.DeleteBucketMetricsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketPolicy = "DeleteBucketPolicy"++// DeleteBucketPolicyRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketPolicy operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketPolicy for more information on using the DeleteBucketPolicy+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketPolicyRequest method.+// req, resp := client.DeleteBucketPolicyRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicy+func (c *S3) DeleteBucketPolicyRequest(input *DeleteBucketPolicyInput) (req *request.Request, output *DeleteBucketPolicyOutput) {+ op := &request.Operation{+ Name: opDeleteBucketPolicy,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?policy",+ }++ if input == nil {+ input = &DeleteBucketPolicyInput{}+ }++ output = &DeleteBucketPolicyOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketPolicy API operation for Amazon Simple Storage Service.+//+// Deletes the policy from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketPolicy for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketPolicy+func (c *S3) DeleteBucketPolicy(input *DeleteBucketPolicyInput) (*DeleteBucketPolicyOutput, error) {+ req, out := c.DeleteBucketPolicyRequest(input)+ return out, req.Send()+}++// DeleteBucketPolicyWithContext is the same as DeleteBucketPolicy with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketPolicy for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketPolicyWithContext(ctx aws.Context, input *DeleteBucketPolicyInput, opts ...request.Option) (*DeleteBucketPolicyOutput, error) {+ req, out := c.DeleteBucketPolicyRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketReplication = "DeleteBucketReplication"++// DeleteBucketReplicationRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketReplication operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketReplication for more information on using the DeleteBucketReplication+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketReplicationRequest method.+// req, resp := client.DeleteBucketReplicationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplication+func (c *S3) DeleteBucketReplicationRequest(input *DeleteBucketReplicationInput) (req *request.Request, output *DeleteBucketReplicationOutput) {+ op := &request.Operation{+ Name: opDeleteBucketReplication,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?replication",+ }++ if input == nil {+ input = &DeleteBucketReplicationInput{}+ }++ output = &DeleteBucketReplicationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketReplication API operation for Amazon Simple Storage Service.+//+// Deletes the replication configuration from the bucket. For information about+// replication configuration, see Cross-Region Replication (CRR) ( https://docs.aws.amazon.com/AmazonS3/latest/dev/crr.html)+// in the Amazon S3 Developer Guide.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketReplication for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketReplication+func (c *S3) DeleteBucketReplication(input *DeleteBucketReplicationInput) (*DeleteBucketReplicationOutput, error) {+ req, out := c.DeleteBucketReplicationRequest(input)+ return out, req.Send()+}++// DeleteBucketReplicationWithContext is the same as DeleteBucketReplication with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketReplication for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketReplicationWithContext(ctx aws.Context, input *DeleteBucketReplicationInput, opts ...request.Option) (*DeleteBucketReplicationOutput, error) {+ req, out := c.DeleteBucketReplicationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketTagging = "DeleteBucketTagging"++// DeleteBucketTaggingRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketTagging for more information on using the DeleteBucketTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketTaggingRequest method.+// req, resp := client.DeleteBucketTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTagging+func (c *S3) DeleteBucketTaggingRequest(input *DeleteBucketTaggingInput) (req *request.Request, output *DeleteBucketTaggingOutput) {+ op := &request.Operation{+ Name: opDeleteBucketTagging,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?tagging",+ }++ if input == nil {+ input = &DeleteBucketTaggingInput{}+ }++ output = &DeleteBucketTaggingOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketTagging API operation for Amazon Simple Storage Service.+//+// Deletes the tags from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketTagging+func (c *S3) DeleteBucketTagging(input *DeleteBucketTaggingInput) (*DeleteBucketTaggingOutput, error) {+ req, out := c.DeleteBucketTaggingRequest(input)+ return out, req.Send()+}++// DeleteBucketTaggingWithContext is the same as DeleteBucketTagging with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketTaggingWithContext(ctx aws.Context, input *DeleteBucketTaggingInput, opts ...request.Option) (*DeleteBucketTaggingOutput, error) {+ req, out := c.DeleteBucketTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteBucketWebsite = "DeleteBucketWebsite"++// DeleteBucketWebsiteRequest generates a "aws/request.Request" representing the+// client's request for the DeleteBucketWebsite operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteBucketWebsite for more information on using the DeleteBucketWebsite+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteBucketWebsiteRequest method.+// req, resp := client.DeleteBucketWebsiteRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsite+func (c *S3) DeleteBucketWebsiteRequest(input *DeleteBucketWebsiteInput) (req *request.Request, output *DeleteBucketWebsiteOutput) {+ op := &request.Operation{+ Name: opDeleteBucketWebsite,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?website",+ }++ if input == nil {+ input = &DeleteBucketWebsiteInput{}+ }++ output = &DeleteBucketWebsiteOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeleteBucketWebsite API operation for Amazon Simple Storage Service.+//+// This operation removes the website configuration from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteBucketWebsite for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteBucketWebsite+func (c *S3) DeleteBucketWebsite(input *DeleteBucketWebsiteInput) (*DeleteBucketWebsiteOutput, error) {+ req, out := c.DeleteBucketWebsiteRequest(input)+ return out, req.Send()+}++// DeleteBucketWebsiteWithContext is the same as DeleteBucketWebsite with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteBucketWebsite for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteBucketWebsiteWithContext(ctx aws.Context, input *DeleteBucketWebsiteInput, opts ...request.Option) (*DeleteBucketWebsiteOutput, error) {+ req, out := c.DeleteBucketWebsiteRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteObject = "DeleteObject"++// DeleteObjectRequest generates a "aws/request.Request" representing the+// client's request for the DeleteObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteObject for more information on using the DeleteObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteObjectRequest method.+// req, resp := client.DeleteObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObject+func (c *S3) DeleteObjectRequest(input *DeleteObjectInput) (req *request.Request, output *DeleteObjectOutput) {+ op := &request.Operation{+ Name: opDeleteObject,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &DeleteObjectInput{}+ }++ output = &DeleteObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// DeleteObject API operation for Amazon Simple Storage Service.+//+// Removes the null version (if there is one) of an object and inserts a delete+// marker, which becomes the latest version of the object. If there isn't a+// null version, Amazon S3 does not remove any objects.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteObject for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObject+func (c *S3) DeleteObject(input *DeleteObjectInput) (*DeleteObjectOutput, error) {+ req, out := c.DeleteObjectRequest(input)+ return out, req.Send()+}++// DeleteObjectWithContext is the same as DeleteObject with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteObjectWithContext(ctx aws.Context, input *DeleteObjectInput, opts ...request.Option) (*DeleteObjectOutput, error) {+ req, out := c.DeleteObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteObjectTagging = "DeleteObjectTagging"++// DeleteObjectTaggingRequest generates a "aws/request.Request" representing the+// client's request for the DeleteObjectTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteObjectTagging for more information on using the DeleteObjectTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteObjectTaggingRequest method.+// req, resp := client.DeleteObjectTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTagging+func (c *S3) DeleteObjectTaggingRequest(input *DeleteObjectTaggingInput) (req *request.Request, output *DeleteObjectTaggingOutput) {+ op := &request.Operation{+ Name: opDeleteObjectTagging,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}/{Key+}?tagging",+ }++ if input == nil {+ input = &DeleteObjectTaggingInput{}+ }++ output = &DeleteObjectTaggingOutput{}+ req = c.newRequest(op, input, output)+ return+}++// DeleteObjectTagging API operation for Amazon Simple Storage Service.+//+// Removes the tag-set from an existing object.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteObjectTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjectTagging+func (c *S3) DeleteObjectTagging(input *DeleteObjectTaggingInput) (*DeleteObjectTaggingOutput, error) {+ req, out := c.DeleteObjectTaggingRequest(input)+ return out, req.Send()+}++// DeleteObjectTaggingWithContext is the same as DeleteObjectTagging with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteObjectTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteObjectTaggingWithContext(ctx aws.Context, input *DeleteObjectTaggingInput, opts ...request.Option) (*DeleteObjectTaggingOutput, error) {+ req, out := c.DeleteObjectTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeleteObjects = "DeleteObjects"++// DeleteObjectsRequest generates a "aws/request.Request" representing the+// client's request for the DeleteObjects operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeleteObjects for more information on using the DeleteObjects+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeleteObjectsRequest method.+// req, resp := client.DeleteObjectsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjects+func (c *S3) DeleteObjectsRequest(input *DeleteObjectsInput) (req *request.Request, output *DeleteObjectsOutput) {+ op := &request.Operation{+ Name: opDeleteObjects,+ HTTPMethod: "POST",+ HTTPPath: "/{Bucket}?delete",+ }++ if input == nil {+ input = &DeleteObjectsInput{}+ }++ output = &DeleteObjectsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// DeleteObjects API operation for Amazon Simple Storage Service.+//+// This operation enables you to delete multiple objects from a bucket using+// a single HTTP request. You may specify up to 1000 keys.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeleteObjects for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteObjects+func (c *S3) DeleteObjects(input *DeleteObjectsInput) (*DeleteObjectsOutput, error) {+ req, out := c.DeleteObjectsRequest(input)+ return out, req.Send()+}++// DeleteObjectsWithContext is the same as DeleteObjects with the addition of+// the ability to pass a context and additional request options.+//+// See DeleteObjects for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeleteObjectsWithContext(ctx aws.Context, input *DeleteObjectsInput, opts ...request.Option) (*DeleteObjectsOutput, error) {+ req, out := c.DeleteObjectsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDeletePublicAccessBlock = "DeletePublicAccessBlock"++// DeletePublicAccessBlockRequest generates a "aws/request.Request" representing the+// client's request for the DeletePublicAccessBlock operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DeletePublicAccessBlock for more information on using the DeletePublicAccessBlock+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DeletePublicAccessBlockRequest method.+// req, resp := client.DeletePublicAccessBlockRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeletePublicAccessBlock+func (c *S3) DeletePublicAccessBlockRequest(input *DeletePublicAccessBlockInput) (req *request.Request, output *DeletePublicAccessBlockOutput) {+ op := &request.Operation{+ Name: opDeletePublicAccessBlock,+ HTTPMethod: "DELETE",+ HTTPPath: "/{Bucket}?publicAccessBlock",+ }++ if input == nil {+ input = &DeletePublicAccessBlockInput{}+ }++ output = &DeletePublicAccessBlockOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// DeletePublicAccessBlock API operation for Amazon Simple Storage Service.+//+// Removes the PublicAccessBlock configuration from an Amazon S3 bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation DeletePublicAccessBlock for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeletePublicAccessBlock+func (c *S3) DeletePublicAccessBlock(input *DeletePublicAccessBlockInput) (*DeletePublicAccessBlockOutput, error) {+ req, out := c.DeletePublicAccessBlockRequest(input)+ return out, req.Send()+}++// DeletePublicAccessBlockWithContext is the same as DeletePublicAccessBlock with the addition of+// the ability to pass a context and additional request options.+//+// See DeletePublicAccessBlock for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) DeletePublicAccessBlockWithContext(ctx aws.Context, input *DeletePublicAccessBlockInput, opts ...request.Option) (*DeletePublicAccessBlockOutput, error) {+ req, out := c.DeletePublicAccessBlockRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketAccelerateConfiguration = "GetBucketAccelerateConfiguration"++// GetBucketAccelerateConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketAccelerateConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketAccelerateConfiguration for more information on using the GetBucketAccelerateConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketAccelerateConfigurationRequest method.+// req, resp := client.GetBucketAccelerateConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfiguration+func (c *S3) GetBucketAccelerateConfigurationRequest(input *GetBucketAccelerateConfigurationInput) (req *request.Request, output *GetBucketAccelerateConfigurationOutput) {+ op := &request.Operation{+ Name: opGetBucketAccelerateConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?accelerate",+ }++ if input == nil {+ input = &GetBucketAccelerateConfigurationInput{}+ }++ output = &GetBucketAccelerateConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketAccelerateConfiguration API operation for Amazon Simple Storage Service.+//+// Returns the accelerate configuration of a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketAccelerateConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAccelerateConfiguration+func (c *S3) GetBucketAccelerateConfiguration(input *GetBucketAccelerateConfigurationInput) (*GetBucketAccelerateConfigurationOutput, error) {+ req, out := c.GetBucketAccelerateConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketAccelerateConfigurationWithContext is the same as GetBucketAccelerateConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketAccelerateConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketAccelerateConfigurationWithContext(ctx aws.Context, input *GetBucketAccelerateConfigurationInput, opts ...request.Option) (*GetBucketAccelerateConfigurationOutput, error) {+ req, out := c.GetBucketAccelerateConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketAcl = "GetBucketAcl"++// GetBucketAclRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketAcl operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketAcl for more information on using the GetBucketAcl+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketAclRequest method.+// req, resp := client.GetBucketAclRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAcl+func (c *S3) GetBucketAclRequest(input *GetBucketAclInput) (req *request.Request, output *GetBucketAclOutput) {+ op := &request.Operation{+ Name: opGetBucketAcl,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?acl",+ }++ if input == nil {+ input = &GetBucketAclInput{}+ }++ output = &GetBucketAclOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketAcl API operation for Amazon Simple Storage Service.+//+// Gets the access control policy for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketAcl for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAcl+func (c *S3) GetBucketAcl(input *GetBucketAclInput) (*GetBucketAclOutput, error) {+ req, out := c.GetBucketAclRequest(input)+ return out, req.Send()+}++// GetBucketAclWithContext is the same as GetBucketAcl with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketAcl for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketAclWithContext(ctx aws.Context, input *GetBucketAclInput, opts ...request.Option) (*GetBucketAclOutput, error) {+ req, out := c.GetBucketAclRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketAnalyticsConfiguration = "GetBucketAnalyticsConfiguration"++// GetBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketAnalyticsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketAnalyticsConfiguration for more information on using the GetBucketAnalyticsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketAnalyticsConfigurationRequest method.+// req, resp := client.GetBucketAnalyticsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfiguration+func (c *S3) GetBucketAnalyticsConfigurationRequest(input *GetBucketAnalyticsConfigurationInput) (req *request.Request, output *GetBucketAnalyticsConfigurationOutput) {+ op := &request.Operation{+ Name: opGetBucketAnalyticsConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?analytics",+ }++ if input == nil {+ input = &GetBucketAnalyticsConfigurationInput{}+ }++ output = &GetBucketAnalyticsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.+//+// Gets an analytics configuration for the bucket (specified by the analytics+// configuration ID).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketAnalyticsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketAnalyticsConfiguration+func (c *S3) GetBucketAnalyticsConfiguration(input *GetBucketAnalyticsConfigurationInput) (*GetBucketAnalyticsConfigurationOutput, error) {+ req, out := c.GetBucketAnalyticsConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketAnalyticsConfigurationWithContext is the same as GetBucketAnalyticsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketAnalyticsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *GetBucketAnalyticsConfigurationInput, opts ...request.Option) (*GetBucketAnalyticsConfigurationOutput, error) {+ req, out := c.GetBucketAnalyticsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketCors = "GetBucketCors"++// GetBucketCorsRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketCors operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketCors for more information on using the GetBucketCors+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketCorsRequest method.+// req, resp := client.GetBucketCorsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCors+func (c *S3) GetBucketCorsRequest(input *GetBucketCorsInput) (req *request.Request, output *GetBucketCorsOutput) {+ op := &request.Operation{+ Name: opGetBucketCors,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?cors",+ }++ if input == nil {+ input = &GetBucketCorsInput{}+ }++ output = &GetBucketCorsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketCors API operation for Amazon Simple Storage Service.+//+// Returns the CORS configuration for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketCors for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketCors+func (c *S3) GetBucketCors(input *GetBucketCorsInput) (*GetBucketCorsOutput, error) {+ req, out := c.GetBucketCorsRequest(input)+ return out, req.Send()+}++// GetBucketCorsWithContext is the same as GetBucketCors with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketCors for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketCorsWithContext(ctx aws.Context, input *GetBucketCorsInput, opts ...request.Option) (*GetBucketCorsOutput, error) {+ req, out := c.GetBucketCorsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketEncryption = "GetBucketEncryption"++// GetBucketEncryptionRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketEncryption operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketEncryption for more information on using the GetBucketEncryption+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketEncryptionRequest method.+// req, resp := client.GetBucketEncryptionRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketEncryption+func (c *S3) GetBucketEncryptionRequest(input *GetBucketEncryptionInput) (req *request.Request, output *GetBucketEncryptionOutput) {+ op := &request.Operation{+ Name: opGetBucketEncryption,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?encryption",+ }++ if input == nil {+ input = &GetBucketEncryptionInput{}+ }++ output = &GetBucketEncryptionOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketEncryption API operation for Amazon Simple Storage Service.+//+// Returns the server-side encryption configuration of a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketEncryption for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketEncryption+func (c *S3) GetBucketEncryption(input *GetBucketEncryptionInput) (*GetBucketEncryptionOutput, error) {+ req, out := c.GetBucketEncryptionRequest(input)+ return out, req.Send()+}++// GetBucketEncryptionWithContext is the same as GetBucketEncryption with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketEncryption for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketEncryptionWithContext(ctx aws.Context, input *GetBucketEncryptionInput, opts ...request.Option) (*GetBucketEncryptionOutput, error) {+ req, out := c.GetBucketEncryptionRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketInventoryConfiguration = "GetBucketInventoryConfiguration"++// GetBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketInventoryConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketInventoryConfiguration for more information on using the GetBucketInventoryConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketInventoryConfigurationRequest method.+// req, resp := client.GetBucketInventoryConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfiguration+func (c *S3) GetBucketInventoryConfigurationRequest(input *GetBucketInventoryConfigurationInput) (req *request.Request, output *GetBucketInventoryConfigurationOutput) {+ op := &request.Operation{+ Name: opGetBucketInventoryConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?inventory",+ }++ if input == nil {+ input = &GetBucketInventoryConfigurationInput{}+ }++ output = &GetBucketInventoryConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketInventoryConfiguration API operation for Amazon Simple Storage Service.+//+// Returns an inventory configuration (identified by the inventory ID) from+// the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketInventoryConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketInventoryConfiguration+func (c *S3) GetBucketInventoryConfiguration(input *GetBucketInventoryConfigurationInput) (*GetBucketInventoryConfigurationOutput, error) {+ req, out := c.GetBucketInventoryConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketInventoryConfigurationWithContext is the same as GetBucketInventoryConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketInventoryConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketInventoryConfigurationWithContext(ctx aws.Context, input *GetBucketInventoryConfigurationInput, opts ...request.Option) (*GetBucketInventoryConfigurationOutput, error) {+ req, out := c.GetBucketInventoryConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketLifecycle = "GetBucketLifecycle"++// GetBucketLifecycleRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketLifecycle operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketLifecycle for more information on using the GetBucketLifecycle+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketLifecycleRequest method.+// req, resp := client.GetBucketLifecycleRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycle+//+// Deprecated: GetBucketLifecycle has been deprecated+func (c *S3) GetBucketLifecycleRequest(input *GetBucketLifecycleInput) (req *request.Request, output *GetBucketLifecycleOutput) {+ if c.Client.Config.Logger != nil {+ c.Client.Config.Logger.Log("This operation, GetBucketLifecycle, has been deprecated")+ }+ op := &request.Operation{+ Name: opGetBucketLifecycle,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?lifecycle",+ }++ if input == nil {+ input = &GetBucketLifecycleInput{}+ }++ output = &GetBucketLifecycleOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketLifecycle API operation for Amazon Simple Storage Service.+//+// Deprecated, see the GetBucketLifecycleConfiguration operation.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketLifecycle for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycle+//+// Deprecated: GetBucketLifecycle has been deprecated+func (c *S3) GetBucketLifecycle(input *GetBucketLifecycleInput) (*GetBucketLifecycleOutput, error) {+ req, out := c.GetBucketLifecycleRequest(input)+ return out, req.Send()+}++// GetBucketLifecycleWithContext is the same as GetBucketLifecycle with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketLifecycle for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+//+// Deprecated: GetBucketLifecycleWithContext has been deprecated+func (c *S3) GetBucketLifecycleWithContext(ctx aws.Context, input *GetBucketLifecycleInput, opts ...request.Option) (*GetBucketLifecycleOutput, error) {+ req, out := c.GetBucketLifecycleRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketLifecycleConfiguration = "GetBucketLifecycleConfiguration"++// GetBucketLifecycleConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketLifecycleConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketLifecycleConfiguration for more information on using the GetBucketLifecycleConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketLifecycleConfigurationRequest method.+// req, resp := client.GetBucketLifecycleConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfiguration+func (c *S3) GetBucketLifecycleConfigurationRequest(input *GetBucketLifecycleConfigurationInput) (req *request.Request, output *GetBucketLifecycleConfigurationOutput) {+ op := &request.Operation{+ Name: opGetBucketLifecycleConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?lifecycle",+ }++ if input == nil {+ input = &GetBucketLifecycleConfigurationInput{}+ }++ output = &GetBucketLifecycleConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketLifecycleConfiguration API operation for Amazon Simple Storage Service.+//+// Returns the lifecycle configuration information set on the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketLifecycleConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLifecycleConfiguration+func (c *S3) GetBucketLifecycleConfiguration(input *GetBucketLifecycleConfigurationInput) (*GetBucketLifecycleConfigurationOutput, error) {+ req, out := c.GetBucketLifecycleConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketLifecycleConfigurationWithContext is the same as GetBucketLifecycleConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketLifecycleConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketLifecycleConfigurationWithContext(ctx aws.Context, input *GetBucketLifecycleConfigurationInput, opts ...request.Option) (*GetBucketLifecycleConfigurationOutput, error) {+ req, out := c.GetBucketLifecycleConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketLocation = "GetBucketLocation"++// GetBucketLocationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketLocation operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketLocation for more information on using the GetBucketLocation+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketLocationRequest method.+// req, resp := client.GetBucketLocationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocation+func (c *S3) GetBucketLocationRequest(input *GetBucketLocationInput) (req *request.Request, output *GetBucketLocationOutput) {+ op := &request.Operation{+ Name: opGetBucketLocation,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?location",+ }++ if input == nil {+ input = &GetBucketLocationInput{}+ }++ output = &GetBucketLocationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketLocation API operation for Amazon Simple Storage Service.+//+// Returns the region the bucket resides in.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketLocation for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLocation+func (c *S3) GetBucketLocation(input *GetBucketLocationInput) (*GetBucketLocationOutput, error) {+ req, out := c.GetBucketLocationRequest(input)+ return out, req.Send()+}++// GetBucketLocationWithContext is the same as GetBucketLocation with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketLocation for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketLocationWithContext(ctx aws.Context, input *GetBucketLocationInput, opts ...request.Option) (*GetBucketLocationOutput, error) {+ req, out := c.GetBucketLocationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketLogging = "GetBucketLogging"++// GetBucketLoggingRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketLogging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketLogging for more information on using the GetBucketLogging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketLoggingRequest method.+// req, resp := client.GetBucketLoggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLogging+func (c *S3) GetBucketLoggingRequest(input *GetBucketLoggingInput) (req *request.Request, output *GetBucketLoggingOutput) {+ op := &request.Operation{+ Name: opGetBucketLogging,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?logging",+ }++ if input == nil {+ input = &GetBucketLoggingInput{}+ }++ output = &GetBucketLoggingOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketLogging API operation for Amazon Simple Storage Service.+//+// 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.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketLogging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketLogging+func (c *S3) GetBucketLogging(input *GetBucketLoggingInput) (*GetBucketLoggingOutput, error) {+ req, out := c.GetBucketLoggingRequest(input)+ return out, req.Send()+}++// GetBucketLoggingWithContext is the same as GetBucketLogging with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketLogging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketLoggingWithContext(ctx aws.Context, input *GetBucketLoggingInput, opts ...request.Option) (*GetBucketLoggingOutput, error) {+ req, out := c.GetBucketLoggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketMetricsConfiguration = "GetBucketMetricsConfiguration"++// GetBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketMetricsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketMetricsConfiguration for more information on using the GetBucketMetricsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketMetricsConfigurationRequest method.+// req, resp := client.GetBucketMetricsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfiguration+func (c *S3) GetBucketMetricsConfigurationRequest(input *GetBucketMetricsConfigurationInput) (req *request.Request, output *GetBucketMetricsConfigurationOutput) {+ op := &request.Operation{+ Name: opGetBucketMetricsConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?metrics",+ }++ if input == nil {+ input = &GetBucketMetricsConfigurationInput{}+ }++ output = &GetBucketMetricsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketMetricsConfiguration API operation for Amazon Simple Storage Service.+//+// Gets a metrics configuration (specified by the metrics configuration ID)+// from the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketMetricsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketMetricsConfiguration+func (c *S3) GetBucketMetricsConfiguration(input *GetBucketMetricsConfigurationInput) (*GetBucketMetricsConfigurationOutput, error) {+ req, out := c.GetBucketMetricsConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketMetricsConfigurationWithContext is the same as GetBucketMetricsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketMetricsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketMetricsConfigurationWithContext(ctx aws.Context, input *GetBucketMetricsConfigurationInput, opts ...request.Option) (*GetBucketMetricsConfigurationOutput, error) {+ req, out := c.GetBucketMetricsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketNotification = "GetBucketNotification"++// GetBucketNotificationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketNotification operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketNotification for more information on using the GetBucketNotification+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketNotificationRequest method.+// req, resp := client.GetBucketNotificationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotification+//+// Deprecated: GetBucketNotification has been deprecated+func (c *S3) GetBucketNotificationRequest(input *GetBucketNotificationConfigurationRequest) (req *request.Request, output *NotificationConfigurationDeprecated) {+ if c.Client.Config.Logger != nil {+ c.Client.Config.Logger.Log("This operation, GetBucketNotification, has been deprecated")+ }+ op := &request.Operation{+ Name: opGetBucketNotification,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?notification",+ }++ if input == nil {+ input = &GetBucketNotificationConfigurationRequest{}+ }++ output = &NotificationConfigurationDeprecated{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketNotification API operation for Amazon Simple Storage Service.+//+// Deprecated, see the GetBucketNotificationConfiguration operation.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketNotification for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotification+//+// Deprecated: GetBucketNotification has been deprecated+func (c *S3) GetBucketNotification(input *GetBucketNotificationConfigurationRequest) (*NotificationConfigurationDeprecated, error) {+ req, out := c.GetBucketNotificationRequest(input)+ return out, req.Send()+}++// GetBucketNotificationWithContext is the same as GetBucketNotification with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketNotification for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+//+// Deprecated: GetBucketNotificationWithContext has been deprecated+func (c *S3) GetBucketNotificationWithContext(ctx aws.Context, input *GetBucketNotificationConfigurationRequest, opts ...request.Option) (*NotificationConfigurationDeprecated, error) {+ req, out := c.GetBucketNotificationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketNotificationConfiguration = "GetBucketNotificationConfiguration"++// GetBucketNotificationConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketNotificationConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketNotificationConfiguration for more information on using the GetBucketNotificationConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketNotificationConfigurationRequest method.+// req, resp := client.GetBucketNotificationConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotificationConfiguration+func (c *S3) GetBucketNotificationConfigurationRequest(input *GetBucketNotificationConfigurationRequest) (req *request.Request, output *NotificationConfiguration) {+ op := &request.Operation{+ Name: opGetBucketNotificationConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?notification",+ }++ if input == nil {+ input = &GetBucketNotificationConfigurationRequest{}+ }++ output = &NotificationConfiguration{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketNotificationConfiguration API operation for Amazon Simple Storage Service.+//+// Returns the notification configuration of a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketNotificationConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketNotificationConfiguration+func (c *S3) GetBucketNotificationConfiguration(input *GetBucketNotificationConfigurationRequest) (*NotificationConfiguration, error) {+ req, out := c.GetBucketNotificationConfigurationRequest(input)+ return out, req.Send()+}++// GetBucketNotificationConfigurationWithContext is the same as GetBucketNotificationConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketNotificationConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketNotificationConfigurationWithContext(ctx aws.Context, input *GetBucketNotificationConfigurationRequest, opts ...request.Option) (*NotificationConfiguration, error) {+ req, out := c.GetBucketNotificationConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketPolicy = "GetBucketPolicy"++// GetBucketPolicyRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketPolicy operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketPolicy for more information on using the GetBucketPolicy+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketPolicyRequest method.+// req, resp := client.GetBucketPolicyRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicy+func (c *S3) GetBucketPolicyRequest(input *GetBucketPolicyInput) (req *request.Request, output *GetBucketPolicyOutput) {+ op := &request.Operation{+ Name: opGetBucketPolicy,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?policy",+ }++ if input == nil {+ input = &GetBucketPolicyInput{}+ }++ output = &GetBucketPolicyOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketPolicy API operation for Amazon Simple Storage Service.+//+// Returns the policy of a specified bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketPolicy for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicy+func (c *S3) GetBucketPolicy(input *GetBucketPolicyInput) (*GetBucketPolicyOutput, error) {+ req, out := c.GetBucketPolicyRequest(input)+ return out, req.Send()+}++// GetBucketPolicyWithContext is the same as GetBucketPolicy with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketPolicy for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketPolicyWithContext(ctx aws.Context, input *GetBucketPolicyInput, opts ...request.Option) (*GetBucketPolicyOutput, error) {+ req, out := c.GetBucketPolicyRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketPolicyStatus = "GetBucketPolicyStatus"++// GetBucketPolicyStatusRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketPolicyStatus operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketPolicyStatus for more information on using the GetBucketPolicyStatus+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketPolicyStatusRequest method.+// req, resp := client.GetBucketPolicyStatusRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicyStatus+func (c *S3) GetBucketPolicyStatusRequest(input *GetBucketPolicyStatusInput) (req *request.Request, output *GetBucketPolicyStatusOutput) {+ op := &request.Operation{+ Name: opGetBucketPolicyStatus,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?policyStatus",+ }++ if input == nil {+ input = &GetBucketPolicyStatusInput{}+ }++ output = &GetBucketPolicyStatusOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketPolicyStatus API operation for Amazon Simple Storage Service.+//+// Retrieves the policy status for an Amazon S3 bucket, indicating whether the+// bucket is public.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketPolicyStatus for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketPolicyStatus+func (c *S3) GetBucketPolicyStatus(input *GetBucketPolicyStatusInput) (*GetBucketPolicyStatusOutput, error) {+ req, out := c.GetBucketPolicyStatusRequest(input)+ return out, req.Send()+}++// GetBucketPolicyStatusWithContext is the same as GetBucketPolicyStatus with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketPolicyStatus for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketPolicyStatusWithContext(ctx aws.Context, input *GetBucketPolicyStatusInput, opts ...request.Option) (*GetBucketPolicyStatusOutput, error) {+ req, out := c.GetBucketPolicyStatusRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketReplication = "GetBucketReplication"++// GetBucketReplicationRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketReplication operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketReplication for more information on using the GetBucketReplication+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketReplicationRequest method.+// req, resp := client.GetBucketReplicationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplication+func (c *S3) GetBucketReplicationRequest(input *GetBucketReplicationInput) (req *request.Request, output *GetBucketReplicationOutput) {+ op := &request.Operation{+ Name: opGetBucketReplication,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?replication",+ }++ if input == nil {+ input = &GetBucketReplicationInput{}+ }++ output = &GetBucketReplicationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketReplication API operation for Amazon Simple Storage Service.+//+// Returns the replication configuration of a bucket.+//+// It can take a while to propagate the put or delete a replication configuration+// to all Amazon S3 systems. Therefore, a get request soon after put or delete+// can return a wrong result.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketReplication for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketReplication+func (c *S3) GetBucketReplication(input *GetBucketReplicationInput) (*GetBucketReplicationOutput, error) {+ req, out := c.GetBucketReplicationRequest(input)+ return out, req.Send()+}++// GetBucketReplicationWithContext is the same as GetBucketReplication with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketReplication for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketReplicationWithContext(ctx aws.Context, input *GetBucketReplicationInput, opts ...request.Option) (*GetBucketReplicationOutput, error) {+ req, out := c.GetBucketReplicationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketRequestPayment = "GetBucketRequestPayment"++// GetBucketRequestPaymentRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketRequestPayment operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketRequestPayment for more information on using the GetBucketRequestPayment+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketRequestPaymentRequest method.+// req, resp := client.GetBucketRequestPaymentRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPayment+func (c *S3) GetBucketRequestPaymentRequest(input *GetBucketRequestPaymentInput) (req *request.Request, output *GetBucketRequestPaymentOutput) {+ op := &request.Operation{+ Name: opGetBucketRequestPayment,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?requestPayment",+ }++ if input == nil {+ input = &GetBucketRequestPaymentInput{}+ }++ output = &GetBucketRequestPaymentOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketRequestPayment API operation for Amazon Simple Storage Service.+//+// Returns the request payment configuration of a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketRequestPayment for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketRequestPayment+func (c *S3) GetBucketRequestPayment(input *GetBucketRequestPaymentInput) (*GetBucketRequestPaymentOutput, error) {+ req, out := c.GetBucketRequestPaymentRequest(input)+ return out, req.Send()+}++// GetBucketRequestPaymentWithContext is the same as GetBucketRequestPayment with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketRequestPayment for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketRequestPaymentWithContext(ctx aws.Context, input *GetBucketRequestPaymentInput, opts ...request.Option) (*GetBucketRequestPaymentOutput, error) {+ req, out := c.GetBucketRequestPaymentRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketTagging = "GetBucketTagging"++// GetBucketTaggingRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketTagging for more information on using the GetBucketTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketTaggingRequest method.+// req, resp := client.GetBucketTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTagging+func (c *S3) GetBucketTaggingRequest(input *GetBucketTaggingInput) (req *request.Request, output *GetBucketTaggingOutput) {+ op := &request.Operation{+ Name: opGetBucketTagging,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?tagging",+ }++ if input == nil {+ input = &GetBucketTaggingInput{}+ }++ output = &GetBucketTaggingOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketTagging API operation for Amazon Simple Storage Service.+//+// Returns the tag set associated with the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketTagging+func (c *S3) GetBucketTagging(input *GetBucketTaggingInput) (*GetBucketTaggingOutput, error) {+ req, out := c.GetBucketTaggingRequest(input)+ return out, req.Send()+}++// GetBucketTaggingWithContext is the same as GetBucketTagging with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketTaggingWithContext(ctx aws.Context, input *GetBucketTaggingInput, opts ...request.Option) (*GetBucketTaggingOutput, error) {+ req, out := c.GetBucketTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketVersioning = "GetBucketVersioning"++// GetBucketVersioningRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketVersioning operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketVersioning for more information on using the GetBucketVersioning+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketVersioningRequest method.+// req, resp := client.GetBucketVersioningRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioning+func (c *S3) GetBucketVersioningRequest(input *GetBucketVersioningInput) (req *request.Request, output *GetBucketVersioningOutput) {+ op := &request.Operation{+ Name: opGetBucketVersioning,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?versioning",+ }++ if input == nil {+ input = &GetBucketVersioningInput{}+ }++ output = &GetBucketVersioningOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketVersioning API operation for Amazon Simple Storage Service.+//+// Returns the versioning state of a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketVersioning for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketVersioning+func (c *S3) GetBucketVersioning(input *GetBucketVersioningInput) (*GetBucketVersioningOutput, error) {+ req, out := c.GetBucketVersioningRequest(input)+ return out, req.Send()+}++// GetBucketVersioningWithContext is the same as GetBucketVersioning with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketVersioning for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketVersioningWithContext(ctx aws.Context, input *GetBucketVersioningInput, opts ...request.Option) (*GetBucketVersioningOutput, error) {+ req, out := c.GetBucketVersioningRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetBucketWebsite = "GetBucketWebsite"++// GetBucketWebsiteRequest generates a "aws/request.Request" representing the+// client's request for the GetBucketWebsite operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetBucketWebsite for more information on using the GetBucketWebsite+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetBucketWebsiteRequest method.+// req, resp := client.GetBucketWebsiteRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsite+func (c *S3) GetBucketWebsiteRequest(input *GetBucketWebsiteInput) (req *request.Request, output *GetBucketWebsiteOutput) {+ op := &request.Operation{+ Name: opGetBucketWebsite,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?website",+ }++ if input == nil {+ input = &GetBucketWebsiteInput{}+ }++ output = &GetBucketWebsiteOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetBucketWebsite API operation for Amazon Simple Storage Service.+//+// Returns the website configuration for a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetBucketWebsite for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetBucketWebsite+func (c *S3) GetBucketWebsite(input *GetBucketWebsiteInput) (*GetBucketWebsiteOutput, error) {+ req, out := c.GetBucketWebsiteRequest(input)+ return out, req.Send()+}++// GetBucketWebsiteWithContext is the same as GetBucketWebsite with the addition of+// the ability to pass a context and additional request options.+//+// See GetBucketWebsite for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetBucketWebsiteWithContext(ctx aws.Context, input *GetBucketWebsiteInput, opts ...request.Option) (*GetBucketWebsiteOutput, error) {+ req, out := c.GetBucketWebsiteRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObject = "GetObject"++// GetObjectRequest generates a "aws/request.Request" representing the+// client's request for the GetObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObject for more information on using the GetObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectRequest method.+// req, resp := client.GetObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObject+func (c *S3) GetObjectRequest(input *GetObjectInput) (req *request.Request, output *GetObjectOutput) {+ op := &request.Operation{+ Name: opGetObject,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &GetObjectInput{}+ }++ output = &GetObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObject API operation for Amazon Simple Storage Service.+//+// Retrieves objects from Amazon S3.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObject for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchKey "NoSuchKey"+// The specified key does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObject+func (c *S3) GetObject(input *GetObjectInput) (*GetObjectOutput, error) {+ req, out := c.GetObjectRequest(input)+ return out, req.Send()+}++// GetObjectWithContext is the same as GetObject with the addition of+// the ability to pass a context and additional request options.+//+// See GetObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectWithContext(ctx aws.Context, input *GetObjectInput, opts ...request.Option) (*GetObjectOutput, error) {+ req, out := c.GetObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectAcl = "GetObjectAcl"++// GetObjectAclRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectAcl operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectAcl for more information on using the GetObjectAcl+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectAclRequest method.+// req, resp := client.GetObjectAclRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAcl+func (c *S3) GetObjectAclRequest(input *GetObjectAclInput) (req *request.Request, output *GetObjectAclOutput) {+ op := &request.Operation{+ Name: opGetObjectAcl,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}?acl",+ }++ if input == nil {+ input = &GetObjectAclInput{}+ }++ output = &GetObjectAclOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectAcl API operation for Amazon Simple Storage Service.+//+// Returns the access control list (ACL) of an object.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectAcl for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchKey "NoSuchKey"+// The specified key does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectAcl+func (c *S3) GetObjectAcl(input *GetObjectAclInput) (*GetObjectAclOutput, error) {+ req, out := c.GetObjectAclRequest(input)+ return out, req.Send()+}++// GetObjectAclWithContext is the same as GetObjectAcl with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectAcl for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectAclWithContext(ctx aws.Context, input *GetObjectAclInput, opts ...request.Option) (*GetObjectAclOutput, error) {+ req, out := c.GetObjectAclRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectLegalHold = "GetObjectLegalHold"++// GetObjectLegalHoldRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectLegalHold operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectLegalHold for more information on using the GetObjectLegalHold+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectLegalHoldRequest method.+// req, resp := client.GetObjectLegalHoldRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectLegalHold+func (c *S3) GetObjectLegalHoldRequest(input *GetObjectLegalHoldInput) (req *request.Request, output *GetObjectLegalHoldOutput) {+ op := &request.Operation{+ Name: opGetObjectLegalHold,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}?legal-hold",+ }++ if input == nil {+ input = &GetObjectLegalHoldInput{}+ }++ output = &GetObjectLegalHoldOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectLegalHold API operation for Amazon Simple Storage Service.+//+// Gets an object's current Legal Hold status.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectLegalHold for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectLegalHold+func (c *S3) GetObjectLegalHold(input *GetObjectLegalHoldInput) (*GetObjectLegalHoldOutput, error) {+ req, out := c.GetObjectLegalHoldRequest(input)+ return out, req.Send()+}++// GetObjectLegalHoldWithContext is the same as GetObjectLegalHold with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectLegalHold for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectLegalHoldWithContext(ctx aws.Context, input *GetObjectLegalHoldInput, opts ...request.Option) (*GetObjectLegalHoldOutput, error) {+ req, out := c.GetObjectLegalHoldRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectLockConfiguration = "GetObjectLockConfiguration"++// GetObjectLockConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectLockConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectLockConfiguration for more information on using the GetObjectLockConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectLockConfigurationRequest method.+// req, resp := client.GetObjectLockConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectLockConfiguration+func (c *S3) GetObjectLockConfigurationRequest(input *GetObjectLockConfigurationInput) (req *request.Request, output *GetObjectLockConfigurationOutput) {+ op := &request.Operation{+ Name: opGetObjectLockConfiguration,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?object-lock",+ }++ if input == nil {+ input = &GetObjectLockConfigurationInput{}+ }++ output = &GetObjectLockConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectLockConfiguration API operation for Amazon Simple Storage Service.+//+// Gets the Object Lock configuration for a bucket. The rule specified in the+// Object Lock configuration will be applied by default to every new object+// placed in the specified bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectLockConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectLockConfiguration+func (c *S3) GetObjectLockConfiguration(input *GetObjectLockConfigurationInput) (*GetObjectLockConfigurationOutput, error) {+ req, out := c.GetObjectLockConfigurationRequest(input)+ return out, req.Send()+}++// GetObjectLockConfigurationWithContext is the same as GetObjectLockConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectLockConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectLockConfigurationWithContext(ctx aws.Context, input *GetObjectLockConfigurationInput, opts ...request.Option) (*GetObjectLockConfigurationOutput, error) {+ req, out := c.GetObjectLockConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectRetention = "GetObjectRetention"++// GetObjectRetentionRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectRetention operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectRetention for more information on using the GetObjectRetention+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectRetentionRequest method.+// req, resp := client.GetObjectRetentionRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectRetention+func (c *S3) GetObjectRetentionRequest(input *GetObjectRetentionInput) (req *request.Request, output *GetObjectRetentionOutput) {+ op := &request.Operation{+ Name: opGetObjectRetention,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}?retention",+ }++ if input == nil {+ input = &GetObjectRetentionInput{}+ }++ output = &GetObjectRetentionOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectRetention API operation for Amazon Simple Storage Service.+//+// Retrieves an object's retention settings.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectRetention for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectRetention+func (c *S3) GetObjectRetention(input *GetObjectRetentionInput) (*GetObjectRetentionOutput, error) {+ req, out := c.GetObjectRetentionRequest(input)+ return out, req.Send()+}++// GetObjectRetentionWithContext is the same as GetObjectRetention with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectRetention for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectRetentionWithContext(ctx aws.Context, input *GetObjectRetentionInput, opts ...request.Option) (*GetObjectRetentionOutput, error) {+ req, out := c.GetObjectRetentionRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectTagging = "GetObjectTagging"++// GetObjectTaggingRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectTagging for more information on using the GetObjectTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectTaggingRequest method.+// req, resp := client.GetObjectTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTagging+func (c *S3) GetObjectTaggingRequest(input *GetObjectTaggingInput) (req *request.Request, output *GetObjectTaggingOutput) {+ op := &request.Operation{+ Name: opGetObjectTagging,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}?tagging",+ }++ if input == nil {+ input = &GetObjectTaggingInput{}+ }++ output = &GetObjectTaggingOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectTagging API operation for Amazon Simple Storage Service.+//+// Returns the tag-set of an object.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTagging+func (c *S3) GetObjectTagging(input *GetObjectTaggingInput) (*GetObjectTaggingOutput, error) {+ req, out := c.GetObjectTaggingRequest(input)+ return out, req.Send()+}++// GetObjectTaggingWithContext is the same as GetObjectTagging with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectTaggingWithContext(ctx aws.Context, input *GetObjectTaggingInput, opts ...request.Option) (*GetObjectTaggingOutput, error) {+ req, out := c.GetObjectTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetObjectTorrent = "GetObjectTorrent"++// GetObjectTorrentRequest generates a "aws/request.Request" representing the+// client's request for the GetObjectTorrent operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetObjectTorrent for more information on using the GetObjectTorrent+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetObjectTorrentRequest method.+// req, resp := client.GetObjectTorrentRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrent+func (c *S3) GetObjectTorrentRequest(input *GetObjectTorrentInput) (req *request.Request, output *GetObjectTorrentOutput) {+ op := &request.Operation{+ Name: opGetObjectTorrent,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}?torrent",+ }++ if input == nil {+ input = &GetObjectTorrentInput{}+ }++ output = &GetObjectTorrentOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetObjectTorrent API operation for Amazon Simple Storage Service.+//+// Return torrent files from a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetObjectTorrent for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetObjectTorrent+func (c *S3) GetObjectTorrent(input *GetObjectTorrentInput) (*GetObjectTorrentOutput, error) {+ req, out := c.GetObjectTorrentRequest(input)+ return out, req.Send()+}++// GetObjectTorrentWithContext is the same as GetObjectTorrent with the addition of+// the ability to pass a context and additional request options.+//+// See GetObjectTorrent for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetObjectTorrentWithContext(ctx aws.Context, input *GetObjectTorrentInput, opts ...request.Option) (*GetObjectTorrentOutput, error) {+ req, out := c.GetObjectTorrentRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetPublicAccessBlock = "GetPublicAccessBlock"++// GetPublicAccessBlockRequest generates a "aws/request.Request" representing the+// client's request for the GetPublicAccessBlock operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetPublicAccessBlock for more information on using the GetPublicAccessBlock+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetPublicAccessBlockRequest method.+// req, resp := client.GetPublicAccessBlockRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetPublicAccessBlock+func (c *S3) GetPublicAccessBlockRequest(input *GetPublicAccessBlockInput) (req *request.Request, output *GetPublicAccessBlockOutput) {+ op := &request.Operation{+ Name: opGetPublicAccessBlock,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?publicAccessBlock",+ }++ if input == nil {+ input = &GetPublicAccessBlockInput{}+ }++ output = &GetPublicAccessBlockOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetPublicAccessBlock API operation for Amazon Simple Storage Service.+//+// Retrieves the PublicAccessBlock configuration for an Amazon S3 bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation GetPublicAccessBlock for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/GetPublicAccessBlock+func (c *S3) GetPublicAccessBlock(input *GetPublicAccessBlockInput) (*GetPublicAccessBlockOutput, error) {+ req, out := c.GetPublicAccessBlockRequest(input)+ return out, req.Send()+}++// GetPublicAccessBlockWithContext is the same as GetPublicAccessBlock with the addition of+// the ability to pass a context and additional request options.+//+// See GetPublicAccessBlock for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) GetPublicAccessBlockWithContext(ctx aws.Context, input *GetPublicAccessBlockInput, opts ...request.Option) (*GetPublicAccessBlockOutput, error) {+ req, out := c.GetPublicAccessBlockRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opHeadBucket = "HeadBucket"++// HeadBucketRequest generates a "aws/request.Request" representing the+// client's request for the HeadBucket operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See HeadBucket for more information on using the HeadBucket+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the HeadBucketRequest method.+// req, resp := client.HeadBucketRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucket+func (c *S3) HeadBucketRequest(input *HeadBucketInput) (req *request.Request, output *HeadBucketOutput) {+ op := &request.Operation{+ Name: opHeadBucket,+ HTTPMethod: "HEAD",+ HTTPPath: "/{Bucket}",+ }++ if input == nil {+ input = &HeadBucketInput{}+ }++ output = &HeadBucketOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// HeadBucket API operation for Amazon Simple Storage Service.+//+// This operation is useful to determine if a bucket exists and you have permission+// to access it.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation HeadBucket for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchBucket "NoSuchBucket"+// The specified bucket does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadBucket+func (c *S3) HeadBucket(input *HeadBucketInput) (*HeadBucketOutput, error) {+ req, out := c.HeadBucketRequest(input)+ return out, req.Send()+}++// HeadBucketWithContext is the same as HeadBucket with the addition of+// the ability to pass a context and additional request options.+//+// See HeadBucket for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) HeadBucketWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.Option) (*HeadBucketOutput, error) {+ req, out := c.HeadBucketRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opHeadObject = "HeadObject"++// HeadObjectRequest generates a "aws/request.Request" representing the+// client's request for the HeadObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See HeadObject for more information on using the HeadObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the HeadObjectRequest method.+// req, resp := client.HeadObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObject+func (c *S3) HeadObjectRequest(input *HeadObjectInput) (req *request.Request, output *HeadObjectOutput) {+ op := &request.Operation{+ Name: opHeadObject,+ HTTPMethod: "HEAD",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &HeadObjectInput{}+ }++ output = &HeadObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// HeadObject API operation for Amazon Simple Storage Service.+//+// The HEAD operation retrieves metadata from an object without returning the+// object itself. This operation is useful if you're only interested in an object's+// metadata. To use HEAD, you must have READ access to the object.+//+// See http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#RESTErrorResponses+// for more information on returned errors.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation HeadObject for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/HeadObject+func (c *S3) HeadObject(input *HeadObjectInput) (*HeadObjectOutput, error) {+ req, out := c.HeadObjectRequest(input)+ return out, req.Send()+}++// HeadObjectWithContext is the same as HeadObject with the addition of+// the ability to pass a context and additional request options.+//+// See HeadObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) HeadObjectWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.Option) (*HeadObjectOutput, error) {+ req, out := c.HeadObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opListBucketAnalyticsConfigurations = "ListBucketAnalyticsConfigurations"++// ListBucketAnalyticsConfigurationsRequest generates a "aws/request.Request" representing the+// client's request for the ListBucketAnalyticsConfigurations operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListBucketAnalyticsConfigurations for more information on using the ListBucketAnalyticsConfigurations+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListBucketAnalyticsConfigurationsRequest method.+// req, resp := client.ListBucketAnalyticsConfigurationsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurations+func (c *S3) ListBucketAnalyticsConfigurationsRequest(input *ListBucketAnalyticsConfigurationsInput) (req *request.Request, output *ListBucketAnalyticsConfigurationsOutput) {+ op := &request.Operation{+ Name: opListBucketAnalyticsConfigurations,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?analytics",+ }++ if input == nil {+ input = &ListBucketAnalyticsConfigurationsInput{}+ }++ output = &ListBucketAnalyticsConfigurationsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListBucketAnalyticsConfigurations API operation for Amazon Simple Storage Service.+//+// Lists the analytics configurations for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListBucketAnalyticsConfigurations for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketAnalyticsConfigurations+func (c *S3) ListBucketAnalyticsConfigurations(input *ListBucketAnalyticsConfigurationsInput) (*ListBucketAnalyticsConfigurationsOutput, error) {+ req, out := c.ListBucketAnalyticsConfigurationsRequest(input)+ return out, req.Send()+}++// ListBucketAnalyticsConfigurationsWithContext is the same as ListBucketAnalyticsConfigurations with the addition of+// the ability to pass a context and additional request options.+//+// See ListBucketAnalyticsConfigurations for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListBucketAnalyticsConfigurationsWithContext(ctx aws.Context, input *ListBucketAnalyticsConfigurationsInput, opts ...request.Option) (*ListBucketAnalyticsConfigurationsOutput, error) {+ req, out := c.ListBucketAnalyticsConfigurationsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opListBucketInventoryConfigurations = "ListBucketInventoryConfigurations"++// ListBucketInventoryConfigurationsRequest generates a "aws/request.Request" representing the+// client's request for the ListBucketInventoryConfigurations operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListBucketInventoryConfigurations for more information on using the ListBucketInventoryConfigurations+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListBucketInventoryConfigurationsRequest method.+// req, resp := client.ListBucketInventoryConfigurationsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurations+func (c *S3) ListBucketInventoryConfigurationsRequest(input *ListBucketInventoryConfigurationsInput) (req *request.Request, output *ListBucketInventoryConfigurationsOutput) {+ op := &request.Operation{+ Name: opListBucketInventoryConfigurations,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?inventory",+ }++ if input == nil {+ input = &ListBucketInventoryConfigurationsInput{}+ }++ output = &ListBucketInventoryConfigurationsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListBucketInventoryConfigurations API operation for Amazon Simple Storage Service.+//+// Returns a list of inventory configurations for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListBucketInventoryConfigurations for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketInventoryConfigurations+func (c *S3) ListBucketInventoryConfigurations(input *ListBucketInventoryConfigurationsInput) (*ListBucketInventoryConfigurationsOutput, error) {+ req, out := c.ListBucketInventoryConfigurationsRequest(input)+ return out, req.Send()+}++// ListBucketInventoryConfigurationsWithContext is the same as ListBucketInventoryConfigurations with the addition of+// the ability to pass a context and additional request options.+//+// See ListBucketInventoryConfigurations for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListBucketInventoryConfigurationsWithContext(ctx aws.Context, input *ListBucketInventoryConfigurationsInput, opts ...request.Option) (*ListBucketInventoryConfigurationsOutput, error) {+ req, out := c.ListBucketInventoryConfigurationsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opListBucketMetricsConfigurations = "ListBucketMetricsConfigurations"++// ListBucketMetricsConfigurationsRequest generates a "aws/request.Request" representing the+// client's request for the ListBucketMetricsConfigurations operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListBucketMetricsConfigurations for more information on using the ListBucketMetricsConfigurations+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListBucketMetricsConfigurationsRequest method.+// req, resp := client.ListBucketMetricsConfigurationsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurations+func (c *S3) ListBucketMetricsConfigurationsRequest(input *ListBucketMetricsConfigurationsInput) (req *request.Request, output *ListBucketMetricsConfigurationsOutput) {+ op := &request.Operation{+ Name: opListBucketMetricsConfigurations,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?metrics",+ }++ if input == nil {+ input = &ListBucketMetricsConfigurationsInput{}+ }++ output = &ListBucketMetricsConfigurationsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListBucketMetricsConfigurations API operation for Amazon Simple Storage Service.+//+// Lists the metrics configurations for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListBucketMetricsConfigurations for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBucketMetricsConfigurations+func (c *S3) ListBucketMetricsConfigurations(input *ListBucketMetricsConfigurationsInput) (*ListBucketMetricsConfigurationsOutput, error) {+ req, out := c.ListBucketMetricsConfigurationsRequest(input)+ return out, req.Send()+}++// ListBucketMetricsConfigurationsWithContext is the same as ListBucketMetricsConfigurations with the addition of+// the ability to pass a context and additional request options.+//+// See ListBucketMetricsConfigurations for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListBucketMetricsConfigurationsWithContext(ctx aws.Context, input *ListBucketMetricsConfigurationsInput, opts ...request.Option) (*ListBucketMetricsConfigurationsOutput, error) {+ req, out := c.ListBucketMetricsConfigurationsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opListBuckets = "ListBuckets"++// ListBucketsRequest generates a "aws/request.Request" representing the+// client's request for the ListBuckets operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListBuckets for more information on using the ListBuckets+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListBucketsRequest method.+// req, resp := client.ListBucketsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBuckets+func (c *S3) ListBucketsRequest(input *ListBucketsInput) (req *request.Request, output *ListBucketsOutput) {+ op := &request.Operation{+ Name: opListBuckets,+ HTTPMethod: "GET",+ HTTPPath: "/",+ }++ if input == nil {+ input = &ListBucketsInput{}+ }++ output = &ListBucketsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListBuckets API operation for Amazon Simple Storage Service.+//+// Returns a list of all buckets owned by the authenticated sender of the request.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListBuckets for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListBuckets+func (c *S3) ListBuckets(input *ListBucketsInput) (*ListBucketsOutput, error) {+ req, out := c.ListBucketsRequest(input)+ return out, req.Send()+}++// ListBucketsWithContext is the same as ListBuckets with the addition of+// the ability to pass a context and additional request options.+//+// See ListBuckets for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListBucketsWithContext(ctx aws.Context, input *ListBucketsInput, opts ...request.Option) (*ListBucketsOutput, error) {+ req, out := c.ListBucketsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opListMultipartUploads = "ListMultipartUploads"++// ListMultipartUploadsRequest generates a "aws/request.Request" representing the+// client's request for the ListMultipartUploads operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListMultipartUploads for more information on using the ListMultipartUploads+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListMultipartUploadsRequest method.+// req, resp := client.ListMultipartUploadsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploads+func (c *S3) ListMultipartUploadsRequest(input *ListMultipartUploadsInput) (req *request.Request, output *ListMultipartUploadsOutput) {+ op := &request.Operation{+ Name: opListMultipartUploads,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?uploads",+ Paginator: &request.Paginator{+ InputTokens: []string{"KeyMarker", "UploadIdMarker"},+ OutputTokens: []string{"NextKeyMarker", "NextUploadIdMarker"},+ LimitToken: "MaxUploads",+ TruncationToken: "IsTruncated",+ },+ }++ if input == nil {+ input = &ListMultipartUploadsInput{}+ }++ output = &ListMultipartUploadsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListMultipartUploads API operation for Amazon Simple Storage Service.+//+// This operation lists in-progress multipart uploads.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListMultipartUploads for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListMultipartUploads+func (c *S3) ListMultipartUploads(input *ListMultipartUploadsInput) (*ListMultipartUploadsOutput, error) {+ req, out := c.ListMultipartUploadsRequest(input)+ return out, req.Send()+}++// ListMultipartUploadsWithContext is the same as ListMultipartUploads with the addition of+// the ability to pass a context and additional request options.+//+// See ListMultipartUploads for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListMultipartUploadsWithContext(ctx aws.Context, input *ListMultipartUploadsInput, opts ...request.Option) (*ListMultipartUploadsOutput, error) {+ req, out := c.ListMultipartUploadsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// ListMultipartUploadsPages iterates over the pages of a ListMultipartUploads operation,+// calling the "fn" function with the response data for each page. To stop+// iterating, return false from the fn function.+//+// See ListMultipartUploads method for more information on how to use this operation.+//+// Note: This operation can generate multiple requests to a service.+//+// // Example iterating over at most 3 pages of a ListMultipartUploads operation.+// pageNum := 0+// err := client.ListMultipartUploadsPages(params,+// func(page *ListMultipartUploadsOutput, lastPage bool) bool {+// pageNum+++// fmt.Println(page)+// return pageNum <= 3+// })+//+func (c *S3) ListMultipartUploadsPages(input *ListMultipartUploadsInput, fn func(*ListMultipartUploadsOutput, bool) bool) error {+ return c.ListMultipartUploadsPagesWithContext(aws.BackgroundContext(), input, fn)+}++// ListMultipartUploadsPagesWithContext same as ListMultipartUploadsPages except+// it takes a Context and allows setting request options on the pages.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListMultipartUploadsPagesWithContext(ctx aws.Context, input *ListMultipartUploadsInput, fn func(*ListMultipartUploadsOutput, bool) bool, opts ...request.Option) error {+ p := request.Pagination{+ NewRequest: func() (*request.Request, error) {+ var inCpy *ListMultipartUploadsInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.ListMultipartUploadsRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }++ cont := true+ for p.Next() && cont {+ cont = fn(p.Page().(*ListMultipartUploadsOutput), !p.HasNextPage())+ }+ return p.Err()+}++const opListObjectVersions = "ListObjectVersions"++// ListObjectVersionsRequest generates a "aws/request.Request" representing the+// client's request for the ListObjectVersions operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListObjectVersions for more information on using the ListObjectVersions+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListObjectVersionsRequest method.+// req, resp := client.ListObjectVersionsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersions+func (c *S3) ListObjectVersionsRequest(input *ListObjectVersionsInput) (req *request.Request, output *ListObjectVersionsOutput) {+ op := &request.Operation{+ Name: opListObjectVersions,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?versions",+ Paginator: &request.Paginator{+ InputTokens: []string{"KeyMarker", "VersionIdMarker"},+ OutputTokens: []string{"NextKeyMarker", "NextVersionIdMarker"},+ LimitToken: "MaxKeys",+ TruncationToken: "IsTruncated",+ },+ }++ if input == nil {+ input = &ListObjectVersionsInput{}+ }++ output = &ListObjectVersionsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListObjectVersions API operation for Amazon Simple Storage Service.+//+// Returns metadata about all of the versions of objects in a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListObjectVersions for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectVersions+func (c *S3) ListObjectVersions(input *ListObjectVersionsInput) (*ListObjectVersionsOutput, error) {+ req, out := c.ListObjectVersionsRequest(input)+ return out, req.Send()+}++// ListObjectVersionsWithContext is the same as ListObjectVersions with the addition of+// the ability to pass a context and additional request options.+//+// See ListObjectVersions for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectVersionsWithContext(ctx aws.Context, input *ListObjectVersionsInput, opts ...request.Option) (*ListObjectVersionsOutput, error) {+ req, out := c.ListObjectVersionsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// ListObjectVersionsPages iterates over the pages of a ListObjectVersions operation,+// calling the "fn" function with the response data for each page. To stop+// iterating, return false from the fn function.+//+// See ListObjectVersions method for more information on how to use this operation.+//+// Note: This operation can generate multiple requests to a service.+//+// // Example iterating over at most 3 pages of a ListObjectVersions operation.+// pageNum := 0+// err := client.ListObjectVersionsPages(params,+// func(page *ListObjectVersionsOutput, lastPage bool) bool {+// pageNum+++// fmt.Println(page)+// return pageNum <= 3+// })+//+func (c *S3) ListObjectVersionsPages(input *ListObjectVersionsInput, fn func(*ListObjectVersionsOutput, bool) bool) error {+ return c.ListObjectVersionsPagesWithContext(aws.BackgroundContext(), input, fn)+}++// ListObjectVersionsPagesWithContext same as ListObjectVersionsPages except+// it takes a Context and allows setting request options on the pages.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectVersionsPagesWithContext(ctx aws.Context, input *ListObjectVersionsInput, fn func(*ListObjectVersionsOutput, bool) bool, opts ...request.Option) error {+ p := request.Pagination{+ NewRequest: func() (*request.Request, error) {+ var inCpy *ListObjectVersionsInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.ListObjectVersionsRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }++ cont := true+ for p.Next() && cont {+ cont = fn(p.Page().(*ListObjectVersionsOutput), !p.HasNextPage())+ }+ return p.Err()+}++const opListObjects = "ListObjects"++// ListObjectsRequest generates a "aws/request.Request" representing the+// client's request for the ListObjects operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListObjects for more information on using the ListObjects+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListObjectsRequest method.+// req, resp := client.ListObjectsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjects+func (c *S3) ListObjectsRequest(input *ListObjectsInput) (req *request.Request, output *ListObjectsOutput) {+ op := &request.Operation{+ Name: opListObjects,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}",+ Paginator: &request.Paginator{+ InputTokens: []string{"Marker"},+ OutputTokens: []string{"NextMarker || Contents[-1].Key"},+ LimitToken: "MaxKeys",+ TruncationToken: "IsTruncated",+ },+ }++ if input == nil {+ input = &ListObjectsInput{}+ }++ output = &ListObjectsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListObjects API operation for Amazon Simple Storage Service.+//+// Returns some or all (up to 1000) of the objects in a bucket. You can use+// the request parameters as selection criteria to return a subset of the objects+// in a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListObjects for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchBucket "NoSuchBucket"+// The specified bucket does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjects+func (c *S3) ListObjects(input *ListObjectsInput) (*ListObjectsOutput, error) {+ req, out := c.ListObjectsRequest(input)+ return out, req.Send()+}++// ListObjectsWithContext is the same as ListObjects with the addition of+// the ability to pass a context and additional request options.+//+// See ListObjects for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectsWithContext(ctx aws.Context, input *ListObjectsInput, opts ...request.Option) (*ListObjectsOutput, error) {+ req, out := c.ListObjectsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// ListObjectsPages iterates over the pages of a ListObjects operation,+// calling the "fn" function with the response data for each page. To stop+// iterating, return false from the fn function.+//+// See ListObjects method for more information on how to use this operation.+//+// Note: This operation can generate multiple requests to a service.+//+// // Example iterating over at most 3 pages of a ListObjects operation.+// pageNum := 0+// err := client.ListObjectsPages(params,+// func(page *ListObjectsOutput, lastPage bool) bool {+// pageNum+++// fmt.Println(page)+// return pageNum <= 3+// })+//+func (c *S3) ListObjectsPages(input *ListObjectsInput, fn func(*ListObjectsOutput, bool) bool) error {+ return c.ListObjectsPagesWithContext(aws.BackgroundContext(), input, fn)+}++// ListObjectsPagesWithContext same as ListObjectsPages except+// it takes a Context and allows setting request options on the pages.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectsPagesWithContext(ctx aws.Context, input *ListObjectsInput, fn func(*ListObjectsOutput, bool) bool, opts ...request.Option) error {+ p := request.Pagination{+ NewRequest: func() (*request.Request, error) {+ var inCpy *ListObjectsInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.ListObjectsRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }++ cont := true+ for p.Next() && cont {+ cont = fn(p.Page().(*ListObjectsOutput), !p.HasNextPage())+ }+ return p.Err()+}++const opListObjectsV2 = "ListObjectsV2"++// ListObjectsV2Request generates a "aws/request.Request" representing the+// client's request for the ListObjectsV2 operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListObjectsV2 for more information on using the ListObjectsV2+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListObjectsV2Request method.+// req, resp := client.ListObjectsV2Request(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2+func (c *S3) ListObjectsV2Request(input *ListObjectsV2Input) (req *request.Request, output *ListObjectsV2Output) {+ op := &request.Operation{+ Name: opListObjectsV2,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}?list-type=2",+ Paginator: &request.Paginator{+ InputTokens: []string{"ContinuationToken"},+ OutputTokens: []string{"NextContinuationToken"},+ LimitToken: "MaxKeys",+ TruncationToken: "",+ },+ }++ if input == nil {+ input = &ListObjectsV2Input{}+ }++ output = &ListObjectsV2Output{}+ req = c.newRequest(op, input, output)+ return+}++// ListObjectsV2 API operation for Amazon Simple Storage Service.+//+// Returns some or all (up to 1000) of the objects in a bucket. You can use+// the request parameters as selection criteria to return a subset of the objects+// in a bucket. Note: ListObjectsV2 is the revised List Objects API and we recommend+// you use this revised API for new application development.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListObjectsV2 for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchBucket "NoSuchBucket"+// The specified bucket does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListObjectsV2+func (c *S3) ListObjectsV2(input *ListObjectsV2Input) (*ListObjectsV2Output, error) {+ req, out := c.ListObjectsV2Request(input)+ return out, req.Send()+}++// ListObjectsV2WithContext is the same as ListObjectsV2 with the addition of+// the ability to pass a context and additional request options.+//+// See ListObjectsV2 for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectsV2WithContext(ctx aws.Context, input *ListObjectsV2Input, opts ...request.Option) (*ListObjectsV2Output, error) {+ req, out := c.ListObjectsV2Request(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// ListObjectsV2Pages iterates over the pages of a ListObjectsV2 operation,+// calling the "fn" function with the response data for each page. To stop+// iterating, return false from the fn function.+//+// See ListObjectsV2 method for more information on how to use this operation.+//+// Note: This operation can generate multiple requests to a service.+//+// // Example iterating over at most 3 pages of a ListObjectsV2 operation.+// pageNum := 0+// err := client.ListObjectsV2Pages(params,+// func(page *ListObjectsV2Output, lastPage bool) bool {+// pageNum+++// fmt.Println(page)+// return pageNum <= 3+// })+//+func (c *S3) ListObjectsV2Pages(input *ListObjectsV2Input, fn func(*ListObjectsV2Output, bool) bool) error {+ return c.ListObjectsV2PagesWithContext(aws.BackgroundContext(), input, fn)+}++// ListObjectsV2PagesWithContext same as ListObjectsV2Pages except+// it takes a Context and allows setting request options on the pages.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListObjectsV2PagesWithContext(ctx aws.Context, input *ListObjectsV2Input, fn func(*ListObjectsV2Output, bool) bool, opts ...request.Option) error {+ p := request.Pagination{+ NewRequest: func() (*request.Request, error) {+ var inCpy *ListObjectsV2Input+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.ListObjectsV2Request(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }++ cont := true+ for p.Next() && cont {+ cont = fn(p.Page().(*ListObjectsV2Output), !p.HasNextPage())+ }+ return p.Err()+}++const opListParts = "ListParts"++// ListPartsRequest generates a "aws/request.Request" representing the+// client's request for the ListParts operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See ListParts for more information on using the ListParts+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the ListPartsRequest method.+// req, resp := client.ListPartsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListParts+func (c *S3) ListPartsRequest(input *ListPartsInput) (req *request.Request, output *ListPartsOutput) {+ op := &request.Operation{+ Name: opListParts,+ HTTPMethod: "GET",+ HTTPPath: "/{Bucket}/{Key+}",+ Paginator: &request.Paginator{+ InputTokens: []string{"PartNumberMarker"},+ OutputTokens: []string{"NextPartNumberMarker"},+ LimitToken: "MaxParts",+ TruncationToken: "IsTruncated",+ },+ }++ if input == nil {+ input = &ListPartsInput{}+ }++ output = &ListPartsOutput{}+ req = c.newRequest(op, input, output)+ return+}++// ListParts API operation for Amazon Simple Storage Service.+//+// Lists the parts that have been uploaded for a specific multipart upload.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation ListParts for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ListParts+func (c *S3) ListParts(input *ListPartsInput) (*ListPartsOutput, error) {+ req, out := c.ListPartsRequest(input)+ return out, req.Send()+}++// ListPartsWithContext is the same as ListParts with the addition of+// the ability to pass a context and additional request options.+//+// See ListParts for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListPartsWithContext(ctx aws.Context, input *ListPartsInput, opts ...request.Option) (*ListPartsOutput, error) {+ req, out := c.ListPartsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// ListPartsPages iterates over the pages of a ListParts operation,+// calling the "fn" function with the response data for each page. To stop+// iterating, return false from the fn function.+//+// See ListParts method for more information on how to use this operation.+//+// Note: This operation can generate multiple requests to a service.+//+// // Example iterating over at most 3 pages of a ListParts operation.+// pageNum := 0+// err := client.ListPartsPages(params,+// func(page *ListPartsOutput, lastPage bool) bool {+// pageNum+++// fmt.Println(page)+// return pageNum <= 3+// })+//+func (c *S3) ListPartsPages(input *ListPartsInput, fn func(*ListPartsOutput, bool) bool) error {+ return c.ListPartsPagesWithContext(aws.BackgroundContext(), input, fn)+}++// ListPartsPagesWithContext same as ListPartsPages except+// it takes a Context and allows setting request options on the pages.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) ListPartsPagesWithContext(ctx aws.Context, input *ListPartsInput, fn func(*ListPartsOutput, bool) bool, opts ...request.Option) error {+ p := request.Pagination{+ NewRequest: func() (*request.Request, error) {+ var inCpy *ListPartsInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.ListPartsRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }++ cont := true+ for p.Next() && cont {+ cont = fn(p.Page().(*ListPartsOutput), !p.HasNextPage())+ }+ return p.Err()+}++const opPutBucketAccelerateConfiguration = "PutBucketAccelerateConfiguration"++// PutBucketAccelerateConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketAccelerateConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketAccelerateConfiguration for more information on using the PutBucketAccelerateConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketAccelerateConfigurationRequest method.+// req, resp := client.PutBucketAccelerateConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfiguration+func (c *S3) PutBucketAccelerateConfigurationRequest(input *PutBucketAccelerateConfigurationInput) (req *request.Request, output *PutBucketAccelerateConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketAccelerateConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?accelerate",+ }++ if input == nil {+ input = &PutBucketAccelerateConfigurationInput{}+ }++ output = &PutBucketAccelerateConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketAccelerateConfiguration API operation for Amazon Simple Storage Service.+//+// Sets the accelerate configuration of an existing bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketAccelerateConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAccelerateConfiguration+func (c *S3) PutBucketAccelerateConfiguration(input *PutBucketAccelerateConfigurationInput) (*PutBucketAccelerateConfigurationOutput, error) {+ req, out := c.PutBucketAccelerateConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketAccelerateConfigurationWithContext is the same as PutBucketAccelerateConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketAccelerateConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketAccelerateConfigurationWithContext(ctx aws.Context, input *PutBucketAccelerateConfigurationInput, opts ...request.Option) (*PutBucketAccelerateConfigurationOutput, error) {+ req, out := c.PutBucketAccelerateConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketAcl = "PutBucketAcl"++// PutBucketAclRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketAcl operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketAcl for more information on using the PutBucketAcl+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketAclRequest method.+// req, resp := client.PutBucketAclRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAcl+func (c *S3) PutBucketAclRequest(input *PutBucketAclInput) (req *request.Request, output *PutBucketAclOutput) {+ op := &request.Operation{+ Name: opPutBucketAcl,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?acl",+ }++ if input == nil {+ input = &PutBucketAclInput{}+ }++ output = &PutBucketAclOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketAcl API operation for Amazon Simple Storage Service.+//+// Sets the permissions on a bucket using access control lists (ACL).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketAcl for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAcl+func (c *S3) PutBucketAcl(input *PutBucketAclInput) (*PutBucketAclOutput, error) {+ req, out := c.PutBucketAclRequest(input)+ return out, req.Send()+}++// PutBucketAclWithContext is the same as PutBucketAcl with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketAcl for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketAclWithContext(ctx aws.Context, input *PutBucketAclInput, opts ...request.Option) (*PutBucketAclOutput, error) {+ req, out := c.PutBucketAclRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketAnalyticsConfiguration = "PutBucketAnalyticsConfiguration"++// PutBucketAnalyticsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketAnalyticsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketAnalyticsConfiguration for more information on using the PutBucketAnalyticsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketAnalyticsConfigurationRequest method.+// req, resp := client.PutBucketAnalyticsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfiguration+func (c *S3) PutBucketAnalyticsConfigurationRequest(input *PutBucketAnalyticsConfigurationInput) (req *request.Request, output *PutBucketAnalyticsConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketAnalyticsConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?analytics",+ }++ if input == nil {+ input = &PutBucketAnalyticsConfigurationInput{}+ }++ output = &PutBucketAnalyticsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketAnalyticsConfiguration API operation for Amazon Simple Storage Service.+//+// Sets an analytics configuration for the bucket (specified by the analytics+// configuration ID).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketAnalyticsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketAnalyticsConfiguration+func (c *S3) PutBucketAnalyticsConfiguration(input *PutBucketAnalyticsConfigurationInput) (*PutBucketAnalyticsConfigurationOutput, error) {+ req, out := c.PutBucketAnalyticsConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketAnalyticsConfigurationWithContext is the same as PutBucketAnalyticsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketAnalyticsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketAnalyticsConfigurationWithContext(ctx aws.Context, input *PutBucketAnalyticsConfigurationInput, opts ...request.Option) (*PutBucketAnalyticsConfigurationOutput, error) {+ req, out := c.PutBucketAnalyticsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketCors = "PutBucketCors"++// PutBucketCorsRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketCors operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketCors for more information on using the PutBucketCors+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketCorsRequest method.+// req, resp := client.PutBucketCorsRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCors+func (c *S3) PutBucketCorsRequest(input *PutBucketCorsInput) (req *request.Request, output *PutBucketCorsOutput) {+ op := &request.Operation{+ Name: opPutBucketCors,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?cors",+ }++ if input == nil {+ input = &PutBucketCorsInput{}+ }++ output = &PutBucketCorsOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketCors API operation for Amazon Simple Storage Service.+//+// Sets the CORS configuration for a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketCors for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketCors+func (c *S3) PutBucketCors(input *PutBucketCorsInput) (*PutBucketCorsOutput, error) {+ req, out := c.PutBucketCorsRequest(input)+ return out, req.Send()+}++// PutBucketCorsWithContext is the same as PutBucketCors with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketCors for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketCorsWithContext(ctx aws.Context, input *PutBucketCorsInput, opts ...request.Option) (*PutBucketCorsOutput, error) {+ req, out := c.PutBucketCorsRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketEncryption = "PutBucketEncryption"++// PutBucketEncryptionRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketEncryption operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketEncryption for more information on using the PutBucketEncryption+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketEncryptionRequest method.+// req, resp := client.PutBucketEncryptionRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketEncryption+func (c *S3) PutBucketEncryptionRequest(input *PutBucketEncryptionInput) (req *request.Request, output *PutBucketEncryptionOutput) {+ op := &request.Operation{+ Name: opPutBucketEncryption,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?encryption",+ }++ if input == nil {+ input = &PutBucketEncryptionInput{}+ }++ output = &PutBucketEncryptionOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketEncryption API operation for Amazon Simple Storage Service.+//+// Creates a new server-side encryption configuration (or replaces an existing+// one, if present).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketEncryption for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketEncryption+func (c *S3) PutBucketEncryption(input *PutBucketEncryptionInput) (*PutBucketEncryptionOutput, error) {+ req, out := c.PutBucketEncryptionRequest(input)+ return out, req.Send()+}++// PutBucketEncryptionWithContext is the same as PutBucketEncryption with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketEncryption for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketEncryptionWithContext(ctx aws.Context, input *PutBucketEncryptionInput, opts ...request.Option) (*PutBucketEncryptionOutput, error) {+ req, out := c.PutBucketEncryptionRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketInventoryConfiguration = "PutBucketInventoryConfiguration"++// PutBucketInventoryConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketInventoryConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketInventoryConfiguration for more information on using the PutBucketInventoryConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketInventoryConfigurationRequest method.+// req, resp := client.PutBucketInventoryConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfiguration+func (c *S3) PutBucketInventoryConfigurationRequest(input *PutBucketInventoryConfigurationInput) (req *request.Request, output *PutBucketInventoryConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketInventoryConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?inventory",+ }++ if input == nil {+ input = &PutBucketInventoryConfigurationInput{}+ }++ output = &PutBucketInventoryConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketInventoryConfiguration API operation for Amazon Simple Storage Service.+//+// Adds an inventory configuration (identified by the inventory ID) from the+// bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketInventoryConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketInventoryConfiguration+func (c *S3) PutBucketInventoryConfiguration(input *PutBucketInventoryConfigurationInput) (*PutBucketInventoryConfigurationOutput, error) {+ req, out := c.PutBucketInventoryConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketInventoryConfigurationWithContext is the same as PutBucketInventoryConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketInventoryConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketInventoryConfigurationWithContext(ctx aws.Context, input *PutBucketInventoryConfigurationInput, opts ...request.Option) (*PutBucketInventoryConfigurationOutput, error) {+ req, out := c.PutBucketInventoryConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketLifecycle = "PutBucketLifecycle"++// PutBucketLifecycleRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketLifecycle operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketLifecycle for more information on using the PutBucketLifecycle+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketLifecycleRequest method.+// req, resp := client.PutBucketLifecycleRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycle+//+// Deprecated: PutBucketLifecycle has been deprecated+func (c *S3) PutBucketLifecycleRequest(input *PutBucketLifecycleInput) (req *request.Request, output *PutBucketLifecycleOutput) {+ if c.Client.Config.Logger != nil {+ c.Client.Config.Logger.Log("This operation, PutBucketLifecycle, has been deprecated")+ }+ op := &request.Operation{+ Name: opPutBucketLifecycle,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?lifecycle",+ }++ if input == nil {+ input = &PutBucketLifecycleInput{}+ }++ output = &PutBucketLifecycleOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketLifecycle API operation for Amazon Simple Storage Service.+//+// Deprecated, see the PutBucketLifecycleConfiguration operation.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketLifecycle for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycle+//+// Deprecated: PutBucketLifecycle has been deprecated+func (c *S3) PutBucketLifecycle(input *PutBucketLifecycleInput) (*PutBucketLifecycleOutput, error) {+ req, out := c.PutBucketLifecycleRequest(input)+ return out, req.Send()+}++// PutBucketLifecycleWithContext is the same as PutBucketLifecycle with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketLifecycle for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+//+// Deprecated: PutBucketLifecycleWithContext has been deprecated+func (c *S3) PutBucketLifecycleWithContext(ctx aws.Context, input *PutBucketLifecycleInput, opts ...request.Option) (*PutBucketLifecycleOutput, error) {+ req, out := c.PutBucketLifecycleRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketLifecycleConfiguration = "PutBucketLifecycleConfiguration"++// PutBucketLifecycleConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketLifecycleConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketLifecycleConfiguration for more information on using the PutBucketLifecycleConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketLifecycleConfigurationRequest method.+// req, resp := client.PutBucketLifecycleConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfiguration+func (c *S3) PutBucketLifecycleConfigurationRequest(input *PutBucketLifecycleConfigurationInput) (req *request.Request, output *PutBucketLifecycleConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketLifecycleConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?lifecycle",+ }++ if input == nil {+ input = &PutBucketLifecycleConfigurationInput{}+ }++ output = &PutBucketLifecycleConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketLifecycleConfiguration API operation for Amazon Simple Storage Service.+//+// Sets lifecycle configuration for your bucket. If a lifecycle configuration+// exists, it replaces it.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketLifecycleConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLifecycleConfiguration+func (c *S3) PutBucketLifecycleConfiguration(input *PutBucketLifecycleConfigurationInput) (*PutBucketLifecycleConfigurationOutput, error) {+ req, out := c.PutBucketLifecycleConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketLifecycleConfigurationWithContext is the same as PutBucketLifecycleConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketLifecycleConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketLifecycleConfigurationWithContext(ctx aws.Context, input *PutBucketLifecycleConfigurationInput, opts ...request.Option) (*PutBucketLifecycleConfigurationOutput, error) {+ req, out := c.PutBucketLifecycleConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketLogging = "PutBucketLogging"++// PutBucketLoggingRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketLogging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketLogging for more information on using the PutBucketLogging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketLoggingRequest method.+// req, resp := client.PutBucketLoggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLogging+func (c *S3) PutBucketLoggingRequest(input *PutBucketLoggingInput) (req *request.Request, output *PutBucketLoggingOutput) {+ op := &request.Operation{+ Name: opPutBucketLogging,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?logging",+ }++ if input == nil {+ input = &PutBucketLoggingInput{}+ }++ output = &PutBucketLoggingOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketLogging API operation for Amazon Simple Storage Service.+//+// Set the logging parameters for a bucket and to specify permissions for who+// can view and modify the logging parameters. To set the logging status of+// a bucket, you must be the bucket owner.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketLogging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketLogging+func (c *S3) PutBucketLogging(input *PutBucketLoggingInput) (*PutBucketLoggingOutput, error) {+ req, out := c.PutBucketLoggingRequest(input)+ return out, req.Send()+}++// PutBucketLoggingWithContext is the same as PutBucketLogging with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketLogging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketLoggingWithContext(ctx aws.Context, input *PutBucketLoggingInput, opts ...request.Option) (*PutBucketLoggingOutput, error) {+ req, out := c.PutBucketLoggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketMetricsConfiguration = "PutBucketMetricsConfiguration"++// PutBucketMetricsConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketMetricsConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketMetricsConfiguration for more information on using the PutBucketMetricsConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketMetricsConfigurationRequest method.+// req, resp := client.PutBucketMetricsConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfiguration+func (c *S3) PutBucketMetricsConfigurationRequest(input *PutBucketMetricsConfigurationInput) (req *request.Request, output *PutBucketMetricsConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketMetricsConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?metrics",+ }++ if input == nil {+ input = &PutBucketMetricsConfigurationInput{}+ }++ output = &PutBucketMetricsConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketMetricsConfiguration API operation for Amazon Simple Storage Service.+//+// Sets a metrics configuration (specified by the metrics configuration ID)+// for the bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketMetricsConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketMetricsConfiguration+func (c *S3) PutBucketMetricsConfiguration(input *PutBucketMetricsConfigurationInput) (*PutBucketMetricsConfigurationOutput, error) {+ req, out := c.PutBucketMetricsConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketMetricsConfigurationWithContext is the same as PutBucketMetricsConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketMetricsConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketMetricsConfigurationWithContext(ctx aws.Context, input *PutBucketMetricsConfigurationInput, opts ...request.Option) (*PutBucketMetricsConfigurationOutput, error) {+ req, out := c.PutBucketMetricsConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketNotification = "PutBucketNotification"++// PutBucketNotificationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketNotification operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketNotification for more information on using the PutBucketNotification+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketNotificationRequest method.+// req, resp := client.PutBucketNotificationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotification+//+// Deprecated: PutBucketNotification has been deprecated+func (c *S3) PutBucketNotificationRequest(input *PutBucketNotificationInput) (req *request.Request, output *PutBucketNotificationOutput) {+ if c.Client.Config.Logger != nil {+ c.Client.Config.Logger.Log("This operation, PutBucketNotification, has been deprecated")+ }+ op := &request.Operation{+ Name: opPutBucketNotification,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?notification",+ }++ if input == nil {+ input = &PutBucketNotificationInput{}+ }++ output = &PutBucketNotificationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketNotification API operation for Amazon Simple Storage Service.+//+// Deprecated, see the PutBucketNotificationConfiguraiton operation.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketNotification for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotification+//+// Deprecated: PutBucketNotification has been deprecated+func (c *S3) PutBucketNotification(input *PutBucketNotificationInput) (*PutBucketNotificationOutput, error) {+ req, out := c.PutBucketNotificationRequest(input)+ return out, req.Send()+}++// PutBucketNotificationWithContext is the same as PutBucketNotification with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketNotification for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+//+// Deprecated: PutBucketNotificationWithContext has been deprecated+func (c *S3) PutBucketNotificationWithContext(ctx aws.Context, input *PutBucketNotificationInput, opts ...request.Option) (*PutBucketNotificationOutput, error) {+ req, out := c.PutBucketNotificationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketNotificationConfiguration = "PutBucketNotificationConfiguration"++// PutBucketNotificationConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketNotificationConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketNotificationConfiguration for more information on using the PutBucketNotificationConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketNotificationConfigurationRequest method.+// req, resp := client.PutBucketNotificationConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfiguration+func (c *S3) PutBucketNotificationConfigurationRequest(input *PutBucketNotificationConfigurationInput) (req *request.Request, output *PutBucketNotificationConfigurationOutput) {+ op := &request.Operation{+ Name: opPutBucketNotificationConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?notification",+ }++ if input == nil {+ input = &PutBucketNotificationConfigurationInput{}+ }++ output = &PutBucketNotificationConfigurationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketNotificationConfiguration API operation for Amazon Simple Storage Service.+//+// Enables notifications of specified events for a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketNotificationConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketNotificationConfiguration+func (c *S3) PutBucketNotificationConfiguration(input *PutBucketNotificationConfigurationInput) (*PutBucketNotificationConfigurationOutput, error) {+ req, out := c.PutBucketNotificationConfigurationRequest(input)+ return out, req.Send()+}++// PutBucketNotificationConfigurationWithContext is the same as PutBucketNotificationConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketNotificationConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketNotificationConfigurationWithContext(ctx aws.Context, input *PutBucketNotificationConfigurationInput, opts ...request.Option) (*PutBucketNotificationConfigurationOutput, error) {+ req, out := c.PutBucketNotificationConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketPolicy = "PutBucketPolicy"++// PutBucketPolicyRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketPolicy operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketPolicy for more information on using the PutBucketPolicy+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketPolicyRequest method.+// req, resp := client.PutBucketPolicyRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicy+func (c *S3) PutBucketPolicyRequest(input *PutBucketPolicyInput) (req *request.Request, output *PutBucketPolicyOutput) {+ op := &request.Operation{+ Name: opPutBucketPolicy,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?policy",+ }++ if input == nil {+ input = &PutBucketPolicyInput{}+ }++ output = &PutBucketPolicyOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketPolicy API operation for Amazon Simple Storage Service.+//+// Replaces a policy on a bucket. If the bucket already has a policy, the one+// in this request completely replaces it.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketPolicy for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketPolicy+func (c *S3) PutBucketPolicy(input *PutBucketPolicyInput) (*PutBucketPolicyOutput, error) {+ req, out := c.PutBucketPolicyRequest(input)+ return out, req.Send()+}++// PutBucketPolicyWithContext is the same as PutBucketPolicy with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketPolicy for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketPolicyWithContext(ctx aws.Context, input *PutBucketPolicyInput, opts ...request.Option) (*PutBucketPolicyOutput, error) {+ req, out := c.PutBucketPolicyRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketReplication = "PutBucketReplication"++// PutBucketReplicationRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketReplication operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketReplication for more information on using the PutBucketReplication+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketReplicationRequest method.+// req, resp := client.PutBucketReplicationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplication+func (c *S3) PutBucketReplicationRequest(input *PutBucketReplicationInput) (req *request.Request, output *PutBucketReplicationOutput) {+ op := &request.Operation{+ Name: opPutBucketReplication,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?replication",+ }++ if input == nil {+ input = &PutBucketReplicationInput{}+ }++ output = &PutBucketReplicationOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketReplication API operation for Amazon Simple Storage Service.+//+// Creates a replication configuration or replaces an existing one. For more+// information, see Cross-Region Replication (CRR) ( https://docs.aws.amazon.com/AmazonS3/latest/dev/crr.html)+// in the Amazon S3 Developer Guide.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketReplication for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketReplication+func (c *S3) PutBucketReplication(input *PutBucketReplicationInput) (*PutBucketReplicationOutput, error) {+ req, out := c.PutBucketReplicationRequest(input)+ return out, req.Send()+}++// PutBucketReplicationWithContext is the same as PutBucketReplication with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketReplication for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketReplicationWithContext(ctx aws.Context, input *PutBucketReplicationInput, opts ...request.Option) (*PutBucketReplicationOutput, error) {+ req, out := c.PutBucketReplicationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketRequestPayment = "PutBucketRequestPayment"++// PutBucketRequestPaymentRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketRequestPayment operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketRequestPayment for more information on using the PutBucketRequestPayment+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketRequestPaymentRequest method.+// req, resp := client.PutBucketRequestPaymentRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPayment+func (c *S3) PutBucketRequestPaymentRequest(input *PutBucketRequestPaymentInput) (req *request.Request, output *PutBucketRequestPaymentOutput) {+ op := &request.Operation{+ Name: opPutBucketRequestPayment,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?requestPayment",+ }++ if input == nil {+ input = &PutBucketRequestPaymentInput{}+ }++ output = &PutBucketRequestPaymentOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketRequestPayment API operation for Amazon Simple Storage Service.+//+// Sets the request payment configuration for a bucket. By default, the bucket+// owner pays for downloads from the bucket. This configuration parameter enables+// the bucket owner (only) to specify that the person requesting the download+// will be charged for the download. Documentation on requester pays buckets+// can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketRequestPayment for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketRequestPayment+func (c *S3) PutBucketRequestPayment(input *PutBucketRequestPaymentInput) (*PutBucketRequestPaymentOutput, error) {+ req, out := c.PutBucketRequestPaymentRequest(input)+ return out, req.Send()+}++// PutBucketRequestPaymentWithContext is the same as PutBucketRequestPayment with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketRequestPayment for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketRequestPaymentWithContext(ctx aws.Context, input *PutBucketRequestPaymentInput, opts ...request.Option) (*PutBucketRequestPaymentOutput, error) {+ req, out := c.PutBucketRequestPaymentRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketTagging = "PutBucketTagging"++// PutBucketTaggingRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketTagging for more information on using the PutBucketTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketTaggingRequest method.+// req, resp := client.PutBucketTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTagging+func (c *S3) PutBucketTaggingRequest(input *PutBucketTaggingInput) (req *request.Request, output *PutBucketTaggingOutput) {+ op := &request.Operation{+ Name: opPutBucketTagging,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?tagging",+ }++ if input == nil {+ input = &PutBucketTaggingInput{}+ }++ output = &PutBucketTaggingOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketTagging API operation for Amazon Simple Storage Service.+//+// Sets the tags for a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketTagging+func (c *S3) PutBucketTagging(input *PutBucketTaggingInput) (*PutBucketTaggingOutput, error) {+ req, out := c.PutBucketTaggingRequest(input)+ return out, req.Send()+}++// PutBucketTaggingWithContext is the same as PutBucketTagging with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketTaggingWithContext(ctx aws.Context, input *PutBucketTaggingInput, opts ...request.Option) (*PutBucketTaggingOutput, error) {+ req, out := c.PutBucketTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketVersioning = "PutBucketVersioning"++// PutBucketVersioningRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketVersioning operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketVersioning for more information on using the PutBucketVersioning+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketVersioningRequest method.+// req, resp := client.PutBucketVersioningRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioning+func (c *S3) PutBucketVersioningRequest(input *PutBucketVersioningInput) (req *request.Request, output *PutBucketVersioningOutput) {+ op := &request.Operation{+ Name: opPutBucketVersioning,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?versioning",+ }++ if input == nil {+ input = &PutBucketVersioningInput{}+ }++ output = &PutBucketVersioningOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketVersioning API operation for Amazon Simple Storage Service.+//+// Sets the versioning state of an existing bucket. To set the versioning state,+// you must be the bucket owner.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketVersioning for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketVersioning+func (c *S3) PutBucketVersioning(input *PutBucketVersioningInput) (*PutBucketVersioningOutput, error) {+ req, out := c.PutBucketVersioningRequest(input)+ return out, req.Send()+}++// PutBucketVersioningWithContext is the same as PutBucketVersioning with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketVersioning for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketVersioningWithContext(ctx aws.Context, input *PutBucketVersioningInput, opts ...request.Option) (*PutBucketVersioningOutput, error) {+ req, out := c.PutBucketVersioningRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutBucketWebsite = "PutBucketWebsite"++// PutBucketWebsiteRequest generates a "aws/request.Request" representing the+// client's request for the PutBucketWebsite operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutBucketWebsite for more information on using the PutBucketWebsite+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutBucketWebsiteRequest method.+// req, resp := client.PutBucketWebsiteRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsite+func (c *S3) PutBucketWebsiteRequest(input *PutBucketWebsiteInput) (req *request.Request, output *PutBucketWebsiteOutput) {+ op := &request.Operation{+ Name: opPutBucketWebsite,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?website",+ }++ if input == nil {+ input = &PutBucketWebsiteInput{}+ }++ output = &PutBucketWebsiteOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutBucketWebsite API operation for Amazon Simple Storage Service.+//+// Set the website configuration for a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutBucketWebsite for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutBucketWebsite+func (c *S3) PutBucketWebsite(input *PutBucketWebsiteInput) (*PutBucketWebsiteOutput, error) {+ req, out := c.PutBucketWebsiteRequest(input)+ return out, req.Send()+}++// PutBucketWebsiteWithContext is the same as PutBucketWebsite with the addition of+// the ability to pass a context and additional request options.+//+// See PutBucketWebsite for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutBucketWebsiteWithContext(ctx aws.Context, input *PutBucketWebsiteInput, opts ...request.Option) (*PutBucketWebsiteOutput, error) {+ req, out := c.PutBucketWebsiteRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObject = "PutObject"++// PutObjectRequest generates a "aws/request.Request" representing the+// client's request for the PutObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObject for more information on using the PutObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectRequest method.+// req, resp := client.PutObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObject+func (c *S3) PutObjectRequest(input *PutObjectInput) (req *request.Request, output *PutObjectOutput) {+ op := &request.Operation{+ Name: opPutObject,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &PutObjectInput{}+ }++ output = &PutObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObject API operation for Amazon Simple Storage Service.+//+// Adds an object to a bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObject for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObject+func (c *S3) PutObject(input *PutObjectInput) (*PutObjectOutput, error) {+ req, out := c.PutObjectRequest(input)+ return out, req.Send()+}++// PutObjectWithContext is the same as PutObject with the addition of+// the ability to pass a context and additional request options.+//+// See PutObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectWithContext(ctx aws.Context, input *PutObjectInput, opts ...request.Option) (*PutObjectOutput, error) {+ req, out := c.PutObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObjectAcl = "PutObjectAcl"++// PutObjectAclRequest generates a "aws/request.Request" representing the+// client's request for the PutObjectAcl operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObjectAcl for more information on using the PutObjectAcl+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectAclRequest method.+// req, resp := client.PutObjectAclRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAcl+func (c *S3) PutObjectAclRequest(input *PutObjectAclInput) (req *request.Request, output *PutObjectAclOutput) {+ op := &request.Operation{+ Name: opPutObjectAcl,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}?acl",+ }++ if input == nil {+ input = &PutObjectAclInput{}+ }++ output = &PutObjectAclOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObjectAcl API operation for Amazon Simple Storage Service.+//+// uses the acl subresource to set the access control list (ACL) permissions+// for an object that already exists in a bucket+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObjectAcl for usage and error information.+//+// Returned Error Codes:+// * ErrCodeNoSuchKey "NoSuchKey"+// The specified key does not exist.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectAcl+func (c *S3) PutObjectAcl(input *PutObjectAclInput) (*PutObjectAclOutput, error) {+ req, out := c.PutObjectAclRequest(input)+ return out, req.Send()+}++// PutObjectAclWithContext is the same as PutObjectAcl with the addition of+// the ability to pass a context and additional request options.+//+// See PutObjectAcl for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectAclWithContext(ctx aws.Context, input *PutObjectAclInput, opts ...request.Option) (*PutObjectAclOutput, error) {+ req, out := c.PutObjectAclRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObjectLegalHold = "PutObjectLegalHold"++// PutObjectLegalHoldRequest generates a "aws/request.Request" representing the+// client's request for the PutObjectLegalHold operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObjectLegalHold for more information on using the PutObjectLegalHold+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectLegalHoldRequest method.+// req, resp := client.PutObjectLegalHoldRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectLegalHold+func (c *S3) PutObjectLegalHoldRequest(input *PutObjectLegalHoldInput) (req *request.Request, output *PutObjectLegalHoldOutput) {+ op := &request.Operation{+ Name: opPutObjectLegalHold,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}?legal-hold",+ }++ if input == nil {+ input = &PutObjectLegalHoldInput{}+ }++ output = &PutObjectLegalHoldOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObjectLegalHold API operation for Amazon Simple Storage Service.+//+// Applies a Legal Hold configuration to the specified object.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObjectLegalHold for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectLegalHold+func (c *S3) PutObjectLegalHold(input *PutObjectLegalHoldInput) (*PutObjectLegalHoldOutput, error) {+ req, out := c.PutObjectLegalHoldRequest(input)+ return out, req.Send()+}++// PutObjectLegalHoldWithContext is the same as PutObjectLegalHold with the addition of+// the ability to pass a context and additional request options.+//+// See PutObjectLegalHold for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectLegalHoldWithContext(ctx aws.Context, input *PutObjectLegalHoldInput, opts ...request.Option) (*PutObjectLegalHoldOutput, error) {+ req, out := c.PutObjectLegalHoldRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObjectLockConfiguration = "PutObjectLockConfiguration"++// PutObjectLockConfigurationRequest generates a "aws/request.Request" representing the+// client's request for the PutObjectLockConfiguration operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObjectLockConfiguration for more information on using the PutObjectLockConfiguration+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectLockConfigurationRequest method.+// req, resp := client.PutObjectLockConfigurationRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectLockConfiguration+func (c *S3) PutObjectLockConfigurationRequest(input *PutObjectLockConfigurationInput) (req *request.Request, output *PutObjectLockConfigurationOutput) {+ op := &request.Operation{+ Name: opPutObjectLockConfiguration,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?object-lock",+ }++ if input == nil {+ input = &PutObjectLockConfigurationInput{}+ }++ output = &PutObjectLockConfigurationOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObjectLockConfiguration API operation for Amazon Simple Storage Service.+//+// Places an Object Lock configuration on the specified bucket. The rule specified+// in the Object Lock configuration will be applied by default to every new+// object placed in the specified bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObjectLockConfiguration for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectLockConfiguration+func (c *S3) PutObjectLockConfiguration(input *PutObjectLockConfigurationInput) (*PutObjectLockConfigurationOutput, error) {+ req, out := c.PutObjectLockConfigurationRequest(input)+ return out, req.Send()+}++// PutObjectLockConfigurationWithContext is the same as PutObjectLockConfiguration with the addition of+// the ability to pass a context and additional request options.+//+// See PutObjectLockConfiguration for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectLockConfigurationWithContext(ctx aws.Context, input *PutObjectLockConfigurationInput, opts ...request.Option) (*PutObjectLockConfigurationOutput, error) {+ req, out := c.PutObjectLockConfigurationRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObjectRetention = "PutObjectRetention"++// PutObjectRetentionRequest generates a "aws/request.Request" representing the+// client's request for the PutObjectRetention operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObjectRetention for more information on using the PutObjectRetention+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectRetentionRequest method.+// req, resp := client.PutObjectRetentionRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectRetention+func (c *S3) PutObjectRetentionRequest(input *PutObjectRetentionInput) (req *request.Request, output *PutObjectRetentionOutput) {+ op := &request.Operation{+ Name: opPutObjectRetention,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}?retention",+ }++ if input == nil {+ input = &PutObjectRetentionInput{}+ }++ output = &PutObjectRetentionOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObjectRetention API operation for Amazon Simple Storage Service.+//+// Places an Object Retention configuration on an object.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObjectRetention for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectRetention+func (c *S3) PutObjectRetention(input *PutObjectRetentionInput) (*PutObjectRetentionOutput, error) {+ req, out := c.PutObjectRetentionRequest(input)+ return out, req.Send()+}++// PutObjectRetentionWithContext is the same as PutObjectRetention with the addition of+// the ability to pass a context and additional request options.+//+// See PutObjectRetention for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectRetentionWithContext(ctx aws.Context, input *PutObjectRetentionInput, opts ...request.Option) (*PutObjectRetentionOutput, error) {+ req, out := c.PutObjectRetentionRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutObjectTagging = "PutObjectTagging"++// PutObjectTaggingRequest generates a "aws/request.Request" representing the+// client's request for the PutObjectTagging operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutObjectTagging for more information on using the PutObjectTagging+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutObjectTaggingRequest method.+// req, resp := client.PutObjectTaggingRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTagging+func (c *S3) PutObjectTaggingRequest(input *PutObjectTaggingInput) (req *request.Request, output *PutObjectTaggingOutput) {+ op := &request.Operation{+ Name: opPutObjectTagging,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}?tagging",+ }++ if input == nil {+ input = &PutObjectTaggingInput{}+ }++ output = &PutObjectTaggingOutput{}+ req = c.newRequest(op, input, output)+ return+}++// PutObjectTagging API operation for Amazon Simple Storage Service.+//+// Sets the supplied tag-set to an object that already exists in a bucket+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutObjectTagging for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutObjectTagging+func (c *S3) PutObjectTagging(input *PutObjectTaggingInput) (*PutObjectTaggingOutput, error) {+ req, out := c.PutObjectTaggingRequest(input)+ return out, req.Send()+}++// PutObjectTaggingWithContext is the same as PutObjectTagging with the addition of+// the ability to pass a context and additional request options.+//+// See PutObjectTagging for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutObjectTaggingWithContext(ctx aws.Context, input *PutObjectTaggingInput, opts ...request.Option) (*PutObjectTaggingOutput, error) {+ req, out := c.PutObjectTaggingRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opPutPublicAccessBlock = "PutPublicAccessBlock"++// PutPublicAccessBlockRequest generates a "aws/request.Request" representing the+// client's request for the PutPublicAccessBlock operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See PutPublicAccessBlock for more information on using the PutPublicAccessBlock+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the PutPublicAccessBlockRequest method.+// req, resp := client.PutPublicAccessBlockRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutPublicAccessBlock+func (c *S3) PutPublicAccessBlockRequest(input *PutPublicAccessBlockInput) (req *request.Request, output *PutPublicAccessBlockOutput) {+ op := &request.Operation{+ Name: opPutPublicAccessBlock,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}?publicAccessBlock",+ }++ if input == nil {+ input = &PutPublicAccessBlockInput{}+ }++ output = &PutPublicAccessBlockOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)+ return+}++// PutPublicAccessBlock API operation for Amazon Simple Storage Service.+//+// Creates or modifies the PublicAccessBlock configuration for an Amazon S3+// bucket.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation PutPublicAccessBlock for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/PutPublicAccessBlock+func (c *S3) PutPublicAccessBlock(input *PutPublicAccessBlockInput) (*PutPublicAccessBlockOutput, error) {+ req, out := c.PutPublicAccessBlockRequest(input)+ return out, req.Send()+}++// PutPublicAccessBlockWithContext is the same as PutPublicAccessBlock with the addition of+// the ability to pass a context and additional request options.+//+// See PutPublicAccessBlock for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) PutPublicAccessBlockWithContext(ctx aws.Context, input *PutPublicAccessBlockInput, opts ...request.Option) (*PutPublicAccessBlockOutput, error) {+ req, out := c.PutPublicAccessBlockRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opRestoreObject = "RestoreObject"++// RestoreObjectRequest generates a "aws/request.Request" representing the+// client's request for the RestoreObject operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See RestoreObject for more information on using the RestoreObject+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the RestoreObjectRequest method.+// req, resp := client.RestoreObjectRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObject+func (c *S3) RestoreObjectRequest(input *RestoreObjectInput) (req *request.Request, output *RestoreObjectOutput) {+ op := &request.Operation{+ Name: opRestoreObject,+ HTTPMethod: "POST",+ HTTPPath: "/{Bucket}/{Key+}?restore",+ }++ if input == nil {+ input = &RestoreObjectInput{}+ }++ output = &RestoreObjectOutput{}+ req = c.newRequest(op, input, output)+ return+}++// RestoreObject API operation for Amazon Simple Storage Service.+//+// Restores an archived copy of an object back into Amazon S3+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation RestoreObject for usage and error information.+//+// Returned Error Codes:+// * ErrCodeObjectAlreadyInActiveTierError "ObjectAlreadyInActiveTierError"+// This operation is not allowed against this storage tier+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/RestoreObject+func (c *S3) RestoreObject(input *RestoreObjectInput) (*RestoreObjectOutput, error) {+ req, out := c.RestoreObjectRequest(input)+ return out, req.Send()+}++// RestoreObjectWithContext is the same as RestoreObject with the addition of+// the ability to pass a context and additional request options.+//+// See RestoreObject for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) RestoreObjectWithContext(ctx aws.Context, input *RestoreObjectInput, opts ...request.Option) (*RestoreObjectOutput, error) {+ req, out := c.RestoreObjectRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opSelectObjectContent = "SelectObjectContent"++// SelectObjectContentRequest generates a "aws/request.Request" representing the+// client's request for the SelectObjectContent operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See SelectObjectContent for more information on using the SelectObjectContent+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the SelectObjectContentRequest method.+// req, resp := client.SelectObjectContentRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/SelectObjectContent+func (c *S3) SelectObjectContentRequest(input *SelectObjectContentInput) (req *request.Request, output *SelectObjectContentOutput) {+ op := &request.Operation{+ Name: opSelectObjectContent,+ HTTPMethod: "POST",+ HTTPPath: "/{Bucket}/{Key+}?select&select-type=2",+ }++ if input == nil {+ input = &SelectObjectContentInput{}+ }++ output = &SelectObjectContentOutput{}+ req = c.newRequest(op, input, output)+ req.Handlers.Send.Swap(client.LogHTTPResponseHandler.Name, client.LogHTTPResponseHeaderHandler)+ req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, rest.UnmarshalHandler)+ req.Handlers.Unmarshal.PushBack(output.runEventStreamLoop)+ return+}++// SelectObjectContent API operation for Amazon Simple Storage Service.+//+// This operation filters the contents of an Amazon S3 object based on a simple+// Structured Query Language (SQL) statement. In the request, along with the+// SQL expression, you must also specify a data serialization format (JSON or+// CSV) of the object. Amazon S3 uses this to parse object data into records,+// and returns only records that match the specified SQL expression. You must+// also specify the data serialization format for the response.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation SelectObjectContent for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/SelectObjectContent+func (c *S3) SelectObjectContent(input *SelectObjectContentInput) (*SelectObjectContentOutput, error) {+ req, out := c.SelectObjectContentRequest(input)+ return out, req.Send()+}++// SelectObjectContentWithContext is the same as SelectObjectContent with the addition of+// the ability to pass a context and additional request options.+//+// See SelectObjectContent for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) SelectObjectContentWithContext(ctx aws.Context, input *SelectObjectContentInput, opts ...request.Option) (*SelectObjectContentOutput, error) {+ req, out := c.SelectObjectContentRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opUploadPart = "UploadPart"++// UploadPartRequest generates a "aws/request.Request" representing the+// client's request for the UploadPart operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See UploadPart for more information on using the UploadPart+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the UploadPartRequest method.+// req, resp := client.UploadPartRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPart+func (c *S3) UploadPartRequest(input *UploadPartInput) (req *request.Request, output *UploadPartOutput) {+ op := &request.Operation{+ Name: opUploadPart,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &UploadPartInput{}+ }++ output = &UploadPartOutput{}+ req = c.newRequest(op, input, output)+ return+}++// UploadPart API operation for Amazon Simple Storage Service.+//+// Uploads a part in a multipart upload.+//+// Note: After you initiate multipart upload and upload one or more parts, you+// must either complete or abort multipart upload in order to stop getting charged+// for storage of the uploaded parts. Only after you either complete or abort+// multipart upload, Amazon S3 frees up the parts storage and stops charging+// you for the parts storage.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation UploadPart for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPart+func (c *S3) UploadPart(input *UploadPartInput) (*UploadPartOutput, error) {+ req, out := c.UploadPartRequest(input)+ return out, req.Send()+}++// UploadPartWithContext is the same as UploadPart with the addition of+// the ability to pass a context and additional request options.+//+// See UploadPart for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) UploadPartWithContext(ctx aws.Context, input *UploadPartInput, opts ...request.Option) (*UploadPartOutput, error) {+ req, out := c.UploadPartRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opUploadPartCopy = "UploadPartCopy"++// UploadPartCopyRequest generates a "aws/request.Request" representing the+// client's request for the UploadPartCopy operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See UploadPartCopy for more information on using the UploadPartCopy+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the UploadPartCopyRequest method.+// req, resp := client.UploadPartCopyRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopy+func (c *S3) UploadPartCopyRequest(input *UploadPartCopyInput) (req *request.Request, output *UploadPartCopyOutput) {+ op := &request.Operation{+ Name: opUploadPartCopy,+ HTTPMethod: "PUT",+ HTTPPath: "/{Bucket}/{Key+}",+ }++ if input == nil {+ input = &UploadPartCopyInput{}+ }++ output = &UploadPartCopyOutput{}+ req = c.newRequest(op, input, output)+ return+}++// UploadPartCopy API operation for Amazon Simple Storage Service.+//+// Uploads a part by copying data from an existing object as data source.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for Amazon Simple Storage Service's+// API operation UploadPartCopy for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/UploadPartCopy+func (c *S3) UploadPartCopy(input *UploadPartCopyInput) (*UploadPartCopyOutput, error) {+ req, out := c.UploadPartCopyRequest(input)+ return out, req.Send()+}++// UploadPartCopyWithContext is the same as UploadPartCopy with the addition of+// the ability to pass a context and additional request options.+//+// See UploadPartCopy for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) UploadPartCopyWithContext(ctx aws.Context, input *UploadPartCopyInput, opts ...request.Option) (*UploadPartCopyOutput, error) {+ req, out := c.UploadPartCopyRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++// Specifies the days since the initiation of an Incomplete Multipart Upload+// that Lifecycle will wait before permanently removing all parts of the upload.+type AbortIncompleteMultipartUpload struct {+ _ struct{} `type:"structure"`++ // Indicates the number of days that must pass since initiation for Lifecycle+ // to abort an Incomplete Multipart Upload.+ DaysAfterInitiation *int64 `type:"integer"`+}++// String returns the string representation+func (s AbortIncompleteMultipartUpload) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AbortIncompleteMultipartUpload) GoString() string {+ return s.String()+}++// SetDaysAfterInitiation sets the DaysAfterInitiation field's value.+func (s *AbortIncompleteMultipartUpload) SetDaysAfterInitiation(v int64) *AbortIncompleteMultipartUpload {+ s.DaysAfterInitiation = &v+ return s+}++type AbortMultipartUploadInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // UploadId is a required field+ UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`+}++// String returns the string representation+func (s AbortMultipartUploadInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AbortMultipartUploadInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AbortMultipartUploadInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AbortMultipartUploadInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.UploadId == nil {+ invalidParams.Add(request.NewErrParamRequired("UploadId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *AbortMultipartUploadInput) SetBucket(v string) *AbortMultipartUploadInput {+ s.Bucket = &v+ return s+}++func (s *AbortMultipartUploadInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *AbortMultipartUploadInput) SetKey(v string) *AbortMultipartUploadInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *AbortMultipartUploadInput) SetRequestPayer(v string) *AbortMultipartUploadInput {+ s.RequestPayer = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *AbortMultipartUploadInput) SetUploadId(v string) *AbortMultipartUploadInput {+ s.UploadId = &v+ return s+}++type AbortMultipartUploadOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s AbortMultipartUploadOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AbortMultipartUploadOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *AbortMultipartUploadOutput) SetRequestCharged(v string) *AbortMultipartUploadOutput {+ s.RequestCharged = &v+ return s+}++type AccelerateConfiguration struct {+ _ struct{} `type:"structure"`++ // The accelerate configuration of the bucket.+ Status *string `type:"string" enum:"BucketAccelerateStatus"`+}++// String returns the string representation+func (s AccelerateConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AccelerateConfiguration) GoString() string {+ return s.String()+}++// SetStatus sets the Status field's value.+func (s *AccelerateConfiguration) SetStatus(v string) *AccelerateConfiguration {+ s.Status = &v+ return s+}++type AccessControlPolicy struct {+ _ struct{} `type:"structure"`++ // A list of grants.+ Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`++ Owner *Owner `type:"structure"`+}++// String returns the string representation+func (s AccessControlPolicy) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AccessControlPolicy) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AccessControlPolicy) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AccessControlPolicy"}+ if s.Grants != nil {+ for i, v := range s.Grants {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Grants", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetGrants sets the Grants field's value.+func (s *AccessControlPolicy) SetGrants(v []*Grant) *AccessControlPolicy {+ s.Grants = v+ return s+}++// SetOwner sets the Owner field's value.+func (s *AccessControlPolicy) SetOwner(v *Owner) *AccessControlPolicy {+ s.Owner = v+ return s+}++// A container for information about access control for replicas.+type AccessControlTranslation struct {+ _ struct{} `type:"structure"`++ // The override value for the owner of the replica object.+ //+ // Owner is a required field+ Owner *string `type:"string" required:"true" enum:"OwnerOverride"`+}++// String returns the string representation+func (s AccessControlTranslation) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AccessControlTranslation) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AccessControlTranslation) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AccessControlTranslation"}+ if s.Owner == nil {+ invalidParams.Add(request.NewErrParamRequired("Owner"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetOwner sets the Owner field's value.+func (s *AccessControlTranslation) SetOwner(v string) *AccessControlTranslation {+ s.Owner = &v+ return s+}++type AnalyticsAndOperator struct {+ _ struct{} `type:"structure"`++ // The prefix to use when evaluating an AND predicate.+ Prefix *string `type:"string"`++ // The list of tags to use when evaluating an AND predicate.+ Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`+}++// String returns the string representation+func (s AnalyticsAndOperator) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AnalyticsAndOperator) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AnalyticsAndOperator) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AnalyticsAndOperator"}+ if s.Tags != nil {+ for i, v := range s.Tags {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPrefix sets the Prefix field's value.+func (s *AnalyticsAndOperator) SetPrefix(v string) *AnalyticsAndOperator {+ s.Prefix = &v+ return s+}++// SetTags sets the Tags field's value.+func (s *AnalyticsAndOperator) SetTags(v []*Tag) *AnalyticsAndOperator {+ s.Tags = v+ return s+}++type AnalyticsConfiguration struct {+ _ struct{} `type:"structure"`++ // The filter used to describe a set of objects for analyses. A filter must+ // have exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator).+ // If no filter is provided, all objects will be considered in any analysis.+ Filter *AnalyticsFilter `type:"structure"`++ // The identifier used to represent an analytics configuration.+ //+ // Id is a required field+ Id *string `type:"string" required:"true"`++ // If present, it indicates that data related to access patterns will be collected+ // and made available to analyze the tradeoffs between different storage classes.+ //+ // StorageClassAnalysis is a required field+ StorageClassAnalysis *StorageClassAnalysis `type:"structure" required:"true"`+}++// String returns the string representation+func (s AnalyticsConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AnalyticsConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AnalyticsConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AnalyticsConfiguration"}+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.StorageClassAnalysis == nil {+ invalidParams.Add(request.NewErrParamRequired("StorageClassAnalysis"))+ }+ if s.Filter != nil {+ if err := s.Filter.Validate(); err != nil {+ invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))+ }+ }+ if s.StorageClassAnalysis != nil {+ if err := s.StorageClassAnalysis.Validate(); err != nil {+ invalidParams.AddNested("StorageClassAnalysis", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetFilter sets the Filter field's value.+func (s *AnalyticsConfiguration) SetFilter(v *AnalyticsFilter) *AnalyticsConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *AnalyticsConfiguration) SetId(v string) *AnalyticsConfiguration {+ s.Id = &v+ return s+}++// SetStorageClassAnalysis sets the StorageClassAnalysis field's value.+func (s *AnalyticsConfiguration) SetStorageClassAnalysis(v *StorageClassAnalysis) *AnalyticsConfiguration {+ s.StorageClassAnalysis = v+ return s+}++type AnalyticsExportDestination struct {+ _ struct{} `type:"structure"`++ // A destination signifying output to an S3 bucket.+ //+ // S3BucketDestination is a required field+ S3BucketDestination *AnalyticsS3BucketDestination `type:"structure" required:"true"`+}++// String returns the string representation+func (s AnalyticsExportDestination) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AnalyticsExportDestination) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AnalyticsExportDestination) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AnalyticsExportDestination"}+ if s.S3BucketDestination == nil {+ invalidParams.Add(request.NewErrParamRequired("S3BucketDestination"))+ }+ if s.S3BucketDestination != nil {+ if err := s.S3BucketDestination.Validate(); err != nil {+ invalidParams.AddNested("S3BucketDestination", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetS3BucketDestination sets the S3BucketDestination field's value.+func (s *AnalyticsExportDestination) SetS3BucketDestination(v *AnalyticsS3BucketDestination) *AnalyticsExportDestination {+ s.S3BucketDestination = v+ return s+}++type AnalyticsFilter struct {+ _ struct{} `type:"structure"`++ // A conjunction (logical AND) of predicates, which is used in evaluating an+ // analytics filter. The operator must have at least two predicates.+ And *AnalyticsAndOperator `type:"structure"`++ // The prefix to use when evaluating an analytics filter.+ Prefix *string `type:"string"`++ // The tag to use when evaluating an analytics filter.+ Tag *Tag `type:"structure"`+}++// String returns the string representation+func (s AnalyticsFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AnalyticsFilter) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AnalyticsFilter) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AnalyticsFilter"}+ if s.And != nil {+ if err := s.And.Validate(); err != nil {+ invalidParams.AddNested("And", err.(request.ErrInvalidParams))+ }+ }+ if s.Tag != nil {+ if err := s.Tag.Validate(); err != nil {+ invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAnd sets the And field's value.+func (s *AnalyticsFilter) SetAnd(v *AnalyticsAndOperator) *AnalyticsFilter {+ s.And = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *AnalyticsFilter) SetPrefix(v string) *AnalyticsFilter {+ s.Prefix = &v+ return s+}++// SetTag sets the Tag field's value.+func (s *AnalyticsFilter) SetTag(v *Tag) *AnalyticsFilter {+ s.Tag = v+ return s+}++type AnalyticsS3BucketDestination struct {+ _ struct{} `type:"structure"`++ // The Amazon resource name (ARN) of the bucket to which data is exported.+ //+ // Bucket is a required field+ Bucket *string `type:"string" required:"true"`++ // The account ID that owns the destination bucket. If no account ID is provided,+ // the owner will not be validated prior to exporting data.+ BucketAccountId *string `type:"string"`++ // The file format used when exporting data to Amazon S3.+ //+ // Format is a required field+ Format *string `type:"string" required:"true" enum:"AnalyticsS3ExportFileFormat"`++ // The prefix to use when exporting data. The exported data begins with this+ // prefix.+ Prefix *string `type:"string"`+}++// String returns the string representation+func (s AnalyticsS3BucketDestination) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AnalyticsS3BucketDestination) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AnalyticsS3BucketDestination) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AnalyticsS3BucketDestination"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Format == nil {+ invalidParams.Add(request.NewErrParamRequired("Format"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *AnalyticsS3BucketDestination) SetBucket(v string) *AnalyticsS3BucketDestination {+ s.Bucket = &v+ return s+}++func (s *AnalyticsS3BucketDestination) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetBucketAccountId sets the BucketAccountId field's value.+func (s *AnalyticsS3BucketDestination) SetBucketAccountId(v string) *AnalyticsS3BucketDestination {+ s.BucketAccountId = &v+ return s+}++// SetFormat sets the Format field's value.+func (s *AnalyticsS3BucketDestination) SetFormat(v string) *AnalyticsS3BucketDestination {+ s.Format = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *AnalyticsS3BucketDestination) SetPrefix(v string) *AnalyticsS3BucketDestination {+ s.Prefix = &v+ return s+}++type Bucket struct {+ _ struct{} `type:"structure"`++ // Date the bucket was created.+ CreationDate *time.Time `type:"timestamp"`++ // The name of the bucket.+ Name *string `type:"string"`+}++// String returns the string representation+func (s Bucket) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Bucket) GoString() string {+ return s.String()+}++// SetCreationDate sets the CreationDate field's value.+func (s *Bucket) SetCreationDate(v time.Time) *Bucket {+ s.CreationDate = &v+ return s+}++// SetName sets the Name field's value.+func (s *Bucket) SetName(v string) *Bucket {+ s.Name = &v+ return s+}++type BucketLifecycleConfiguration struct {+ _ struct{} `type:"structure"`++ // Rules is a required field+ Rules []*LifecycleRule `locationName:"Rule" type:"list" flattened:"true" required:"true"`+}++// String returns the string representation+func (s BucketLifecycleConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s BucketLifecycleConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *BucketLifecycleConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "BucketLifecycleConfiguration"}+ if s.Rules == nil {+ invalidParams.Add(request.NewErrParamRequired("Rules"))+ }+ if s.Rules != nil {+ for i, v := range s.Rules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetRules sets the Rules field's value.+func (s *BucketLifecycleConfiguration) SetRules(v []*LifecycleRule) *BucketLifecycleConfiguration {+ s.Rules = v+ return s+}++type BucketLoggingStatus struct {+ _ struct{} `type:"structure"`++ // Container for logging information. Presence of this element indicates that+ // logging is enabled. Parameters TargetBucket and TargetPrefix are required+ // in this case.+ LoggingEnabled *LoggingEnabled `type:"structure"`+}++// String returns the string representation+func (s BucketLoggingStatus) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s BucketLoggingStatus) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *BucketLoggingStatus) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "BucketLoggingStatus"}+ if s.LoggingEnabled != nil {+ if err := s.LoggingEnabled.Validate(); err != nil {+ invalidParams.AddNested("LoggingEnabled", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetLoggingEnabled sets the LoggingEnabled field's value.+func (s *BucketLoggingStatus) SetLoggingEnabled(v *LoggingEnabled) *BucketLoggingStatus {+ s.LoggingEnabled = v+ return s+}++type CORSConfiguration struct {+ _ struct{} `type:"structure"`++ // CORSRules is a required field+ CORSRules []*CORSRule `locationName:"CORSRule" type:"list" flattened:"true" required:"true"`+}++// String returns the string representation+func (s CORSConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CORSConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CORSConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CORSConfiguration"}+ if s.CORSRules == nil {+ invalidParams.Add(request.NewErrParamRequired("CORSRules"))+ }+ if s.CORSRules != nil {+ for i, v := range s.CORSRules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "CORSRules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetCORSRules sets the CORSRules field's value.+func (s *CORSConfiguration) SetCORSRules(v []*CORSRule) *CORSConfiguration {+ s.CORSRules = v+ return s+}++type CORSRule struct {+ _ struct{} `type:"structure"`++ // Specifies which headers are allowed in a pre-flight OPTIONS request.+ AllowedHeaders []*string `locationName:"AllowedHeader" type:"list" flattened:"true"`++ // Identifies HTTP methods that the domain/origin specified in the rule is allowed+ // to execute.+ //+ // AllowedMethods is a required field+ AllowedMethods []*string `locationName:"AllowedMethod" type:"list" flattened:"true" required:"true"`++ // One or more origins you want customers to be able to access the bucket from.+ //+ // AllowedOrigins is a required field+ AllowedOrigins []*string `locationName:"AllowedOrigin" type:"list" flattened:"true" required:"true"`++ // One or more headers in the response that you want customers to be able to+ // access from their applications (for example, from a JavaScript XMLHttpRequest+ // object).+ ExposeHeaders []*string `locationName:"ExposeHeader" type:"list" flattened:"true"`++ // The time in seconds that your browser is to cache the preflight response+ // for the specified resource.+ MaxAgeSeconds *int64 `type:"integer"`+}++// String returns the string representation+func (s CORSRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CORSRule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CORSRule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CORSRule"}+ if s.AllowedMethods == nil {+ invalidParams.Add(request.NewErrParamRequired("AllowedMethods"))+ }+ if s.AllowedOrigins == nil {+ invalidParams.Add(request.NewErrParamRequired("AllowedOrigins"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAllowedHeaders sets the AllowedHeaders field's value.+func (s *CORSRule) SetAllowedHeaders(v []*string) *CORSRule {+ s.AllowedHeaders = v+ return s+}++// SetAllowedMethods sets the AllowedMethods field's value.+func (s *CORSRule) SetAllowedMethods(v []*string) *CORSRule {+ s.AllowedMethods = v+ return s+}++// SetAllowedOrigins sets the AllowedOrigins field's value.+func (s *CORSRule) SetAllowedOrigins(v []*string) *CORSRule {+ s.AllowedOrigins = v+ return s+}++// SetExposeHeaders sets the ExposeHeaders field's value.+func (s *CORSRule) SetExposeHeaders(v []*string) *CORSRule {+ s.ExposeHeaders = v+ return s+}++// SetMaxAgeSeconds sets the MaxAgeSeconds field's value.+func (s *CORSRule) SetMaxAgeSeconds(v int64) *CORSRule {+ s.MaxAgeSeconds = &v+ return s+}++// Describes how a CSV-formatted input object is formatted.+type CSVInput struct {+ _ struct{} `type:"structure"`++ // Specifies that CSV field values may contain quoted record delimiters and+ // such records should be allowed. Default value is FALSE. Setting this value+ // to TRUE may lower performance.+ AllowQuotedRecordDelimiter *bool `type:"boolean"`++ // The single character used to indicate a row should be ignored when present+ // at the start of a row.+ Comments *string `type:"string"`++ // The value used to separate individual fields in a record.+ FieldDelimiter *string `type:"string"`++ // Describes the first line of input. Valid values: None, Ignore, Use.+ FileHeaderInfo *string `type:"string" enum:"FileHeaderInfo"`++ // Value used for escaping where the field delimiter is part of the value.+ QuoteCharacter *string `type:"string"`++ // The single character used for escaping the quote character inside an already+ // escaped value.+ QuoteEscapeCharacter *string `type:"string"`++ // The value used to separate individual records.+ RecordDelimiter *string `type:"string"`+}++// String returns the string representation+func (s CSVInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CSVInput) GoString() string {+ return s.String()+}++// SetAllowQuotedRecordDelimiter sets the AllowQuotedRecordDelimiter field's value.+func (s *CSVInput) SetAllowQuotedRecordDelimiter(v bool) *CSVInput {+ s.AllowQuotedRecordDelimiter = &v+ return s+}++// SetComments sets the Comments field's value.+func (s *CSVInput) SetComments(v string) *CSVInput {+ s.Comments = &v+ return s+}++// SetFieldDelimiter sets the FieldDelimiter field's value.+func (s *CSVInput) SetFieldDelimiter(v string) *CSVInput {+ s.FieldDelimiter = &v+ return s+}++// SetFileHeaderInfo sets the FileHeaderInfo field's value.+func (s *CSVInput) SetFileHeaderInfo(v string) *CSVInput {+ s.FileHeaderInfo = &v+ return s+}++// SetQuoteCharacter sets the QuoteCharacter field's value.+func (s *CSVInput) SetQuoteCharacter(v string) *CSVInput {+ s.QuoteCharacter = &v+ return s+}++// SetQuoteEscapeCharacter sets the QuoteEscapeCharacter field's value.+func (s *CSVInput) SetQuoteEscapeCharacter(v string) *CSVInput {+ s.QuoteEscapeCharacter = &v+ return s+}++// SetRecordDelimiter sets the RecordDelimiter field's value.+func (s *CSVInput) SetRecordDelimiter(v string) *CSVInput {+ s.RecordDelimiter = &v+ return s+}++// Describes how CSV-formatted results are formatted.+type CSVOutput struct {+ _ struct{} `type:"structure"`++ // The value used to separate individual fields in a record.+ FieldDelimiter *string `type:"string"`++ // The value used for escaping where the field delimiter is part of the value.+ QuoteCharacter *string `type:"string"`++ // Th single character used for escaping the quote character inside an already+ // escaped value.+ QuoteEscapeCharacter *string `type:"string"`++ // Indicates whether or not all output fields should be quoted.+ QuoteFields *string `type:"string" enum:"QuoteFields"`++ // The value used to separate individual records.+ RecordDelimiter *string `type:"string"`+}++// String returns the string representation+func (s CSVOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CSVOutput) GoString() string {+ return s.String()+}++// SetFieldDelimiter sets the FieldDelimiter field's value.+func (s *CSVOutput) SetFieldDelimiter(v string) *CSVOutput {+ s.FieldDelimiter = &v+ return s+}++// SetQuoteCharacter sets the QuoteCharacter field's value.+func (s *CSVOutput) SetQuoteCharacter(v string) *CSVOutput {+ s.QuoteCharacter = &v+ return s+}++// SetQuoteEscapeCharacter sets the QuoteEscapeCharacter field's value.+func (s *CSVOutput) SetQuoteEscapeCharacter(v string) *CSVOutput {+ s.QuoteEscapeCharacter = &v+ return s+}++// SetQuoteFields sets the QuoteFields field's value.+func (s *CSVOutput) SetQuoteFields(v string) *CSVOutput {+ s.QuoteFields = &v+ return s+}++// SetRecordDelimiter sets the RecordDelimiter field's value.+func (s *CSVOutput) SetRecordDelimiter(v string) *CSVOutput {+ s.RecordDelimiter = &v+ return s+}++type CloudFunctionConfiguration struct {+ _ struct{} `type:"structure"`++ CloudFunction *string `type:"string"`++ // The bucket event for which to send notifications.+ //+ // Deprecated: Event has been deprecated+ Event *string `deprecated:"true" type:"string" enum:"Event"`++ Events []*string `locationName:"Event" type:"list" flattened:"true"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ InvocationRole *string `type:"string"`+}++// String returns the string representation+func (s CloudFunctionConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CloudFunctionConfiguration) GoString() string {+ return s.String()+}++// SetCloudFunction sets the CloudFunction field's value.+func (s *CloudFunctionConfiguration) SetCloudFunction(v string) *CloudFunctionConfiguration {+ s.CloudFunction = &v+ return s+}++// SetEvent sets the Event field's value.+func (s *CloudFunctionConfiguration) SetEvent(v string) *CloudFunctionConfiguration {+ s.Event = &v+ return s+}++// SetEvents sets the Events field's value.+func (s *CloudFunctionConfiguration) SetEvents(v []*string) *CloudFunctionConfiguration {+ s.Events = v+ return s+}++// SetId sets the Id field's value.+func (s *CloudFunctionConfiguration) SetId(v string) *CloudFunctionConfiguration {+ s.Id = &v+ return s+}++// SetInvocationRole sets the InvocationRole field's value.+func (s *CloudFunctionConfiguration) SetInvocationRole(v string) *CloudFunctionConfiguration {+ s.InvocationRole = &v+ return s+}++type CommonPrefix struct {+ _ struct{} `type:"structure"`++ Prefix *string `type:"string"`+}++// String returns the string representation+func (s CommonPrefix) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CommonPrefix) GoString() string {+ return s.String()+}++// SetPrefix sets the Prefix field's value.+func (s *CommonPrefix) SetPrefix(v string) *CommonPrefix {+ s.Prefix = &v+ return s+}++type CompleteMultipartUploadInput struct {+ _ struct{} `type:"structure" payload:"MultipartUpload"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ MultipartUpload *CompletedMultipartUpload `locationName:"CompleteMultipartUpload" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // 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" enum:"RequestPayer"`++ // UploadId is a required field+ UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`+}++// String returns the string representation+func (s CompleteMultipartUploadInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CompleteMultipartUploadInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CompleteMultipartUploadInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CompleteMultipartUploadInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.UploadId == nil {+ invalidParams.Add(request.NewErrParamRequired("UploadId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *CompleteMultipartUploadInput) SetBucket(v string) *CompleteMultipartUploadInput {+ s.Bucket = &v+ return s+}++func (s *CompleteMultipartUploadInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *CompleteMultipartUploadInput) SetKey(v string) *CompleteMultipartUploadInput {+ s.Key = &v+ return s+}++// SetMultipartUpload sets the MultipartUpload field's value.+func (s *CompleteMultipartUploadInput) SetMultipartUpload(v *CompletedMultipartUpload) *CompleteMultipartUploadInput {+ s.MultipartUpload = v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *CompleteMultipartUploadInput) SetRequestPayer(v string) *CompleteMultipartUploadInput {+ s.RequestPayer = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *CompleteMultipartUploadInput) SetUploadId(v string) *CompleteMultipartUploadInput {+ s.UploadId = &v+ return s+}++type CompleteMultipartUploadOutput struct {+ _ struct{} `type:"structure"`++ Bucket *string `type:"string"`++ // Entity tag of the object.+ ETag *string `type:"string"`++ // If the object expiration is configured, this will contain the expiration+ // date (expiry-date) and rule ID (rule-id). The value of rule-id is URL encoded.+ Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`++ Key *string `min:"1" type:"string"`++ Location *string `type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // Version of the object.+ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s CompleteMultipartUploadOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CompleteMultipartUploadOutput) GoString() string {+ return s.String()+}++// SetBucket sets the Bucket field's value.+func (s *CompleteMultipartUploadOutput) SetBucket(v string) *CompleteMultipartUploadOutput {+ s.Bucket = &v+ return s+}++func (s *CompleteMultipartUploadOutput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetETag sets the ETag field's value.+func (s *CompleteMultipartUploadOutput) SetETag(v string) *CompleteMultipartUploadOutput {+ s.ETag = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *CompleteMultipartUploadOutput) SetExpiration(v string) *CompleteMultipartUploadOutput {+ s.Expiration = &v+ return s+}++// SetKey sets the Key field's value.+func (s *CompleteMultipartUploadOutput) SetKey(v string) *CompleteMultipartUploadOutput {+ s.Key = &v+ return s+}++// SetLocation sets the Location field's value.+func (s *CompleteMultipartUploadOutput) SetLocation(v string) *CompleteMultipartUploadOutput {+ s.Location = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *CompleteMultipartUploadOutput) SetRequestCharged(v string) *CompleteMultipartUploadOutput {+ s.RequestCharged = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *CompleteMultipartUploadOutput) SetSSEKMSKeyId(v string) *CompleteMultipartUploadOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *CompleteMultipartUploadOutput) SetServerSideEncryption(v string) *CompleteMultipartUploadOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *CompleteMultipartUploadOutput) SetVersionId(v string) *CompleteMultipartUploadOutput {+ s.VersionId = &v+ return s+}++type CompletedMultipartUpload struct {+ _ struct{} `type:"structure"`++ Parts []*CompletedPart `locationName:"Part" type:"list" flattened:"true"`+}++// String returns the string representation+func (s CompletedMultipartUpload) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CompletedMultipartUpload) GoString() string {+ return s.String()+}++// SetParts sets the Parts field's value.+func (s *CompletedMultipartUpload) SetParts(v []*CompletedPart) *CompletedMultipartUpload {+ s.Parts = v+ return s+}++type CompletedPart struct {+ _ struct{} `type:"structure"`++ // Entity tag returned when the part was uploaded.+ ETag *string `type:"string"`++ // Part number that identifies the part. This is a positive integer between+ // 1 and 10,000.+ PartNumber *int64 `type:"integer"`+}++// String returns the string representation+func (s CompletedPart) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CompletedPart) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *CompletedPart) SetETag(v string) *CompletedPart {+ s.ETag = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *CompletedPart) SetPartNumber(v int64) *CompletedPart {+ s.PartNumber = &v+ return s+}++type Condition struct {+ _ struct{} `type:"structure"`++ // The HTTP error code when the redirect is applied. In the event of an error,+ // if the error code equals this value, then the specified redirect is applied.+ // Required when parent element Condition is specified and sibling KeyPrefixEquals+ // is not specified. If both are specified, then both must be true for the redirect+ // to be applied.+ HttpErrorCodeReturnedEquals *string `type:"string"`++ // The object key name prefix when the redirect is applied. For example, to+ // redirect requests for ExamplePage.html, the key prefix will be ExamplePage.html.+ // To redirect request for all pages with the prefix docs/, the key prefix will+ // be /docs, which identifies all objects in the docs/ folder. Required when+ // the parent element Condition is specified and sibling HttpErrorCodeReturnedEquals+ // is not specified. If both conditions are specified, both must be true for+ // the redirect to be applied.+ KeyPrefixEquals *string `type:"string"`+}++// String returns the string representation+func (s Condition) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Condition) GoString() string {+ return s.String()+}++// SetHttpErrorCodeReturnedEquals sets the HttpErrorCodeReturnedEquals field's value.+func (s *Condition) SetHttpErrorCodeReturnedEquals(v string) *Condition {+ s.HttpErrorCodeReturnedEquals = &v+ return s+}++// SetKeyPrefixEquals sets the KeyPrefixEquals field's value.+func (s *Condition) SetKeyPrefixEquals(v string) *Condition {+ s.KeyPrefixEquals = &v+ return s+}++type ContinuationEvent struct {+ _ struct{} `locationName:"ContinuationEvent" type:"structure"`+}++// String returns the string representation+func (s ContinuationEvent) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ContinuationEvent) GoString() string {+ return s.String()+}++// The ContinuationEvent is and event in the SelectObjectContentEventStream group of events.+func (s *ContinuationEvent) eventSelectObjectContentEventStream() {}++// UnmarshalEvent unmarshals the EventStream Message into the ContinuationEvent value.+// This method is only used internally within the SDK's EventStream handling.+func (s *ContinuationEvent) UnmarshalEvent(+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ msg eventstream.Message,+) error {+ return nil+}++type CopyObjectInput struct {+ _ struct{} `type:"structure"`++ // The canned ACL to apply to the object.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`++ // Bucket is a required field+ 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 name of the source bucket and key name of the source object, separated+ // by a slash (/). Must be URL-encoded.+ //+ // CopySource is a required field+ CopySource *string `location:"header" locationName:"x-amz-copy-source" type:"string" required:"true"`++ // Copies the object if its entity tag (ETag) matches the specified tag.+ CopySourceIfMatch *string `location:"header" locationName:"x-amz-copy-source-if-match" type:"string"`++ // Copies the object if it has been modified since the specified time.+ CopySourceIfModifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-modified-since" type:"timestamp"`++ // Copies the object if its entity tag (ETag) is different than the specified+ // ETag.+ CopySourceIfNoneMatch *string `location:"header" locationName:"x-amz-copy-source-if-none-match" type:"string"`++ // Copies the object if it hasn't been modified since the specified time.+ CopySourceIfUnmodifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-unmodified-since" type:"timestamp"`++ // Specifies the algorithm to use when decrypting the source object (e.g., AES256).+ CopySourceSSECustomerAlgorithm *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-algorithm" type:"string"`++ // Specifies the customer-provided encryption key for Amazon S3 to use to decrypt+ // the source object. The encryption key provided in this header must be one+ // that was used when the source object was created.+ CopySourceSSECustomerKey *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key" type:"string" sensitive:"true"`++ // 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.+ CopySourceSSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key-MD5" type:"string"`++ // The date and time at which the object is no longer cacheable.+ Expires *time.Time `location:"header" locationName:"Expires" type:"timestamp"`++ // 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 is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" 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"`++ // Specifies whether the metadata is copied from the source object or replaced+ // with metadata provided in the request.+ MetadataDirective *string `location:"header" locationName:"x-amz-metadata-directive" type:"string" enum:"MetadataDirective"`++ // Specifies whether you want to apply a Legal Hold to the copied object.+ ObjectLockLegalHoldStatus *string `location:"header" locationName:"x-amz-object-lock-legal-hold" type:"string" enum:"ObjectLockLegalHoldStatus"`++ // The Object Lock mode that you want to apply to the copied object.+ ObjectLockMode *string `location:"header" locationName:"x-amz-object-lock-mode" type:"string" enum:"ObjectLockMode"`++ // The date and time when you want the copied object's Object Lock to expire.+ ObjectLockRetainUntilDate *time.Time `location:"header" locationName:"x-amz-object-lock-retain-until-date" type:"timestamp" timestampFormat:"iso8601"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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" sensitive:"true"`++ // 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" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // The type of storage to use for the object. Defaults to 'STANDARD'.+ StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`++ // The tag-set for the object destination object this value must be used in+ // conjunction with the TaggingDirective. The tag-set must be encoded as URL+ // Query parameters+ Tagging *string `location:"header" locationName:"x-amz-tagging" type:"string"`++ // Specifies whether the object tag-set are copied from the source object or+ // replaced with tag-set provided in the request.+ TaggingDirective *string `location:"header" locationName:"x-amz-tagging-directive" type:"string" enum:"TaggingDirective"`++ // 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"`+}++// String returns the string representation+func (s CopyObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CopyObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CopyObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CopyObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.CopySource == nil {+ invalidParams.Add(request.NewErrParamRequired("CopySource"))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *CopyObjectInput) SetACL(v string) *CopyObjectInput {+ s.ACL = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *CopyObjectInput) SetBucket(v string) *CopyObjectInput {+ s.Bucket = &v+ return s+}++func (s *CopyObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCacheControl sets the CacheControl field's value.+func (s *CopyObjectInput) SetCacheControl(v string) *CopyObjectInput {+ s.CacheControl = &v+ return s+}++// SetContentDisposition sets the ContentDisposition field's value.+func (s *CopyObjectInput) SetContentDisposition(v string) *CopyObjectInput {+ s.ContentDisposition = &v+ return s+}++// SetContentEncoding sets the ContentEncoding field's value.+func (s *CopyObjectInput) SetContentEncoding(v string) *CopyObjectInput {+ s.ContentEncoding = &v+ return s+}++// SetContentLanguage sets the ContentLanguage field's value.+func (s *CopyObjectInput) SetContentLanguage(v string) *CopyObjectInput {+ s.ContentLanguage = &v+ return s+}++// SetContentType sets the ContentType field's value.+func (s *CopyObjectInput) SetContentType(v string) *CopyObjectInput {+ s.ContentType = &v+ return s+}++// SetCopySource sets the CopySource field's value.+func (s *CopyObjectInput) SetCopySource(v string) *CopyObjectInput {+ s.CopySource = &v+ return s+}++// SetCopySourceIfMatch sets the CopySourceIfMatch field's value.+func (s *CopyObjectInput) SetCopySourceIfMatch(v string) *CopyObjectInput {+ s.CopySourceIfMatch = &v+ return s+}++// SetCopySourceIfModifiedSince sets the CopySourceIfModifiedSince field's value.+func (s *CopyObjectInput) SetCopySourceIfModifiedSince(v time.Time) *CopyObjectInput {+ s.CopySourceIfModifiedSince = &v+ return s+}++// SetCopySourceIfNoneMatch sets the CopySourceIfNoneMatch field's value.+func (s *CopyObjectInput) SetCopySourceIfNoneMatch(v string) *CopyObjectInput {+ s.CopySourceIfNoneMatch = &v+ return s+}++// SetCopySourceIfUnmodifiedSince sets the CopySourceIfUnmodifiedSince field's value.+func (s *CopyObjectInput) SetCopySourceIfUnmodifiedSince(v time.Time) *CopyObjectInput {+ s.CopySourceIfUnmodifiedSince = &v+ return s+}++// SetCopySourceSSECustomerAlgorithm sets the CopySourceSSECustomerAlgorithm field's value.+func (s *CopyObjectInput) SetCopySourceSSECustomerAlgorithm(v string) *CopyObjectInput {+ s.CopySourceSSECustomerAlgorithm = &v+ return s+}++// SetCopySourceSSECustomerKey sets the CopySourceSSECustomerKey field's value.+func (s *CopyObjectInput) SetCopySourceSSECustomerKey(v string) *CopyObjectInput {+ s.CopySourceSSECustomerKey = &v+ return s+}++func (s *CopyObjectInput) getCopySourceSSECustomerKey() (v string) {+ if s.CopySourceSSECustomerKey == nil {+ return v+ }+ return *s.CopySourceSSECustomerKey+}++// SetCopySourceSSECustomerKeyMD5 sets the CopySourceSSECustomerKeyMD5 field's value.+func (s *CopyObjectInput) SetCopySourceSSECustomerKeyMD5(v string) *CopyObjectInput {+ s.CopySourceSSECustomerKeyMD5 = &v+ return s+}++// SetExpires sets the Expires field's value.+func (s *CopyObjectInput) SetExpires(v time.Time) *CopyObjectInput {+ s.Expires = &v+ return s+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *CopyObjectInput) SetGrantFullControl(v string) *CopyObjectInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *CopyObjectInput) SetGrantRead(v string) *CopyObjectInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *CopyObjectInput) SetGrantReadACP(v string) *CopyObjectInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *CopyObjectInput) SetGrantWriteACP(v string) *CopyObjectInput {+ s.GrantWriteACP = &v+ return s+}++// SetKey sets the Key field's value.+func (s *CopyObjectInput) SetKey(v string) *CopyObjectInput {+ s.Key = &v+ return s+}++// SetMetadata sets the Metadata field's value.+func (s *CopyObjectInput) SetMetadata(v map[string]*string) *CopyObjectInput {+ s.Metadata = v+ return s+}++// SetMetadataDirective sets the MetadataDirective field's value.+func (s *CopyObjectInput) SetMetadataDirective(v string) *CopyObjectInput {+ s.MetadataDirective = &v+ return s+}++// SetObjectLockLegalHoldStatus sets the ObjectLockLegalHoldStatus field's value.+func (s *CopyObjectInput) SetObjectLockLegalHoldStatus(v string) *CopyObjectInput {+ s.ObjectLockLegalHoldStatus = &v+ return s+}++// SetObjectLockMode sets the ObjectLockMode field's value.+func (s *CopyObjectInput) SetObjectLockMode(v string) *CopyObjectInput {+ s.ObjectLockMode = &v+ return s+}++// SetObjectLockRetainUntilDate sets the ObjectLockRetainUntilDate field's value.+func (s *CopyObjectInput) SetObjectLockRetainUntilDate(v time.Time) *CopyObjectInput {+ s.ObjectLockRetainUntilDate = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *CopyObjectInput) SetRequestPayer(v string) *CopyObjectInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *CopyObjectInput) SetSSECustomerAlgorithm(v string) *CopyObjectInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *CopyObjectInput) SetSSECustomerKey(v string) *CopyObjectInput {+ s.SSECustomerKey = &v+ return s+}++func (s *CopyObjectInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *CopyObjectInput) SetSSECustomerKeyMD5(v string) *CopyObjectInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *CopyObjectInput) SetSSEKMSKeyId(v string) *CopyObjectInput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *CopyObjectInput) SetServerSideEncryption(v string) *CopyObjectInput {+ s.ServerSideEncryption = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *CopyObjectInput) SetStorageClass(v string) *CopyObjectInput {+ s.StorageClass = &v+ return s+}++// SetTagging sets the Tagging field's value.+func (s *CopyObjectInput) SetTagging(v string) *CopyObjectInput {+ s.Tagging = &v+ return s+}++// SetTaggingDirective sets the TaggingDirective field's value.+func (s *CopyObjectInput) SetTaggingDirective(v string) *CopyObjectInput {+ s.TaggingDirective = &v+ return s+}++// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.+func (s *CopyObjectInput) SetWebsiteRedirectLocation(v string) *CopyObjectInput {+ s.WebsiteRedirectLocation = &v+ return s+}++type CopyObjectOutput struct {+ _ struct{} `type:"structure" payload:"CopyObjectResult"`++ CopyObjectResult *CopyObjectResult `type:"structure"`++ CopySourceVersionId *string `location:"header" locationName:"x-amz-copy-source-version-id" type:"string"`++ // If the object expiration is configured, the response includes this header.+ Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // Version ID of the newly created copy.+ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s CopyObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CopyObjectOutput) GoString() string {+ return s.String()+}++// SetCopyObjectResult sets the CopyObjectResult field's value.+func (s *CopyObjectOutput) SetCopyObjectResult(v *CopyObjectResult) *CopyObjectOutput {+ s.CopyObjectResult = v+ return s+}++// SetCopySourceVersionId sets the CopySourceVersionId field's value.+func (s *CopyObjectOutput) SetCopySourceVersionId(v string) *CopyObjectOutput {+ s.CopySourceVersionId = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *CopyObjectOutput) SetExpiration(v string) *CopyObjectOutput {+ s.Expiration = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *CopyObjectOutput) SetRequestCharged(v string) *CopyObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *CopyObjectOutput) SetSSECustomerAlgorithm(v string) *CopyObjectOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *CopyObjectOutput) SetSSECustomerKeyMD5(v string) *CopyObjectOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *CopyObjectOutput) SetSSEKMSKeyId(v string) *CopyObjectOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *CopyObjectOutput) SetServerSideEncryption(v string) *CopyObjectOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *CopyObjectOutput) SetVersionId(v string) *CopyObjectOutput {+ s.VersionId = &v+ return s+}++type CopyObjectResult struct {+ _ struct{} `type:"structure"`++ ETag *string `type:"string"`++ LastModified *time.Time `type:"timestamp"`+}++// String returns the string representation+func (s CopyObjectResult) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CopyObjectResult) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *CopyObjectResult) SetETag(v string) *CopyObjectResult {+ s.ETag = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *CopyObjectResult) SetLastModified(v time.Time) *CopyObjectResult {+ s.LastModified = &v+ return s+}++type CopyPartResult struct {+ _ struct{} `type:"structure"`++ // Entity tag of the object.+ ETag *string `type:"string"`++ // Date and time at which the object was uploaded.+ LastModified *time.Time `type:"timestamp"`+}++// String returns the string representation+func (s CopyPartResult) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CopyPartResult) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *CopyPartResult) SetETag(v string) *CopyPartResult {+ s.ETag = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *CopyPartResult) SetLastModified(v time.Time) *CopyPartResult {+ s.LastModified = &v+ return s+}++type CreateBucketConfiguration struct {+ _ struct{} `type:"structure"`++ // Specifies the region where the bucket will be created. If you don't specify+ // a region, the bucket will be created in US Standard.+ LocationConstraint *string `type:"string" enum:"BucketLocationConstraint"`+}++// String returns the string representation+func (s CreateBucketConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CreateBucketConfiguration) GoString() string {+ return s.String()+}++// SetLocationConstraint sets the LocationConstraint field's value.+func (s *CreateBucketConfiguration) SetLocationConstraint(v string) *CreateBucketConfiguration {+ s.LocationConstraint = &v+ return s+}++type CreateBucketInput struct {+ _ struct{} `type:"structure" payload:"CreateBucketConfiguration"`++ // The canned ACL to apply to the bucket.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"BucketCannedACL"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ CreateBucketConfiguration *CreateBucketConfiguration `locationName:"CreateBucketConfiguration" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // Allows grantee the read, write, read ACP, and write ACP permissions on the+ // bucket.+ GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`++ // Allows grantee to list the objects in the bucket.+ GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`++ // Allows grantee to read the bucket ACL.+ GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`++ // Allows grantee to create, overwrite, and delete any object in the bucket.+ GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`++ // Allows grantee to write the ACL for the applicable bucket.+ GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`++ // Specifies whether you want S3 Object Lock to be enabled for the new bucket.+ ObjectLockEnabledForBucket *bool `location:"header" locationName:"x-amz-bucket-object-lock-enabled" type:"boolean"`+}++// String returns the string representation+func (s CreateBucketInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CreateBucketInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CreateBucketInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CreateBucketInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *CreateBucketInput) SetACL(v string) *CreateBucketInput {+ s.ACL = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *CreateBucketInput) SetBucket(v string) *CreateBucketInput {+ s.Bucket = &v+ return s+}++func (s *CreateBucketInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCreateBucketConfiguration sets the CreateBucketConfiguration field's value.+func (s *CreateBucketInput) SetCreateBucketConfiguration(v *CreateBucketConfiguration) *CreateBucketInput {+ s.CreateBucketConfiguration = v+ return s+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *CreateBucketInput) SetGrantFullControl(v string) *CreateBucketInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *CreateBucketInput) SetGrantRead(v string) *CreateBucketInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *CreateBucketInput) SetGrantReadACP(v string) *CreateBucketInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWrite sets the GrantWrite field's value.+func (s *CreateBucketInput) SetGrantWrite(v string) *CreateBucketInput {+ s.GrantWrite = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *CreateBucketInput) SetGrantWriteACP(v string) *CreateBucketInput {+ s.GrantWriteACP = &v+ return s+}++// SetObjectLockEnabledForBucket sets the ObjectLockEnabledForBucket field's value.+func (s *CreateBucketInput) SetObjectLockEnabledForBucket(v bool) *CreateBucketInput {+ s.ObjectLockEnabledForBucket = &v+ return s+}++type CreateBucketOutput struct {+ _ struct{} `type:"structure"`++ Location *string `location:"header" locationName:"Location" type:"string"`+}++// String returns the string representation+func (s CreateBucketOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CreateBucketOutput) GoString() string {+ return s.String()+}++// SetLocation sets the Location field's value.+func (s *CreateBucketOutput) SetLocation(v string) *CreateBucketOutput {+ s.Location = &v+ return s+}++type CreateMultipartUploadInput struct {+ _ struct{} `type:"structure"`++ // The canned ACL to apply to the object.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`++ // Bucket is a required field+ 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"`++ // 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 is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" 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"`++ // Specifies whether you want to apply a Legal Hold to the uploaded object.+ ObjectLockLegalHoldStatus *string `location:"header" locationName:"x-amz-object-lock-legal-hold" type:"string" enum:"ObjectLockLegalHoldStatus"`++ // Specifies the Object Lock mode that you want to apply to the uploaded object.+ ObjectLockMode *string `location:"header" locationName:"x-amz-object-lock-mode" type:"string" enum:"ObjectLockMode"`++ // Specifies the date and time when you want the Object Lock to expire.+ ObjectLockRetainUntilDate *time.Time `location:"header" locationName:"x-amz-object-lock-retain-until-date" type:"timestamp" timestampFormat:"iso8601"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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" sensitive:"true"`++ // 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" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // The type of storage to use for the object. Defaults to 'STANDARD'.+ StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`++ // The tag-set for the object. The tag-set must be encoded as URL Query parameters+ Tagging *string `location:"header" locationName:"x-amz-tagging" 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"`+}++// String returns the string representation+func (s CreateMultipartUploadInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CreateMultipartUploadInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *CreateMultipartUploadInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "CreateMultipartUploadInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *CreateMultipartUploadInput) SetACL(v string) *CreateMultipartUploadInput {+ s.ACL = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *CreateMultipartUploadInput) SetBucket(v string) *CreateMultipartUploadInput {+ s.Bucket = &v+ return s+}++func (s *CreateMultipartUploadInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCacheControl sets the CacheControl field's value.+func (s *CreateMultipartUploadInput) SetCacheControl(v string) *CreateMultipartUploadInput {+ s.CacheControl = &v+ return s+}++// SetContentDisposition sets the ContentDisposition field's value.+func (s *CreateMultipartUploadInput) SetContentDisposition(v string) *CreateMultipartUploadInput {+ s.ContentDisposition = &v+ return s+}++// SetContentEncoding sets the ContentEncoding field's value.+func (s *CreateMultipartUploadInput) SetContentEncoding(v string) *CreateMultipartUploadInput {+ s.ContentEncoding = &v+ return s+}++// SetContentLanguage sets the ContentLanguage field's value.+func (s *CreateMultipartUploadInput) SetContentLanguage(v string) *CreateMultipartUploadInput {+ s.ContentLanguage = &v+ return s+}++// SetContentType sets the ContentType field's value.+func (s *CreateMultipartUploadInput) SetContentType(v string) *CreateMultipartUploadInput {+ s.ContentType = &v+ return s+}++// SetExpires sets the Expires field's value.+func (s *CreateMultipartUploadInput) SetExpires(v time.Time) *CreateMultipartUploadInput {+ s.Expires = &v+ return s+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *CreateMultipartUploadInput) SetGrantFullControl(v string) *CreateMultipartUploadInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *CreateMultipartUploadInput) SetGrantRead(v string) *CreateMultipartUploadInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *CreateMultipartUploadInput) SetGrantReadACP(v string) *CreateMultipartUploadInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *CreateMultipartUploadInput) SetGrantWriteACP(v string) *CreateMultipartUploadInput {+ s.GrantWriteACP = &v+ return s+}++// SetKey sets the Key field's value.+func (s *CreateMultipartUploadInput) SetKey(v string) *CreateMultipartUploadInput {+ s.Key = &v+ return s+}++// SetMetadata sets the Metadata field's value.+func (s *CreateMultipartUploadInput) SetMetadata(v map[string]*string) *CreateMultipartUploadInput {+ s.Metadata = v+ return s+}++// SetObjectLockLegalHoldStatus sets the ObjectLockLegalHoldStatus field's value.+func (s *CreateMultipartUploadInput) SetObjectLockLegalHoldStatus(v string) *CreateMultipartUploadInput {+ s.ObjectLockLegalHoldStatus = &v+ return s+}++// SetObjectLockMode sets the ObjectLockMode field's value.+func (s *CreateMultipartUploadInput) SetObjectLockMode(v string) *CreateMultipartUploadInput {+ s.ObjectLockMode = &v+ return s+}++// SetObjectLockRetainUntilDate sets the ObjectLockRetainUntilDate field's value.+func (s *CreateMultipartUploadInput) SetObjectLockRetainUntilDate(v time.Time) *CreateMultipartUploadInput {+ s.ObjectLockRetainUntilDate = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *CreateMultipartUploadInput) SetRequestPayer(v string) *CreateMultipartUploadInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *CreateMultipartUploadInput) SetSSECustomerAlgorithm(v string) *CreateMultipartUploadInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *CreateMultipartUploadInput) SetSSECustomerKey(v string) *CreateMultipartUploadInput {+ s.SSECustomerKey = &v+ return s+}++func (s *CreateMultipartUploadInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *CreateMultipartUploadInput) SetSSECustomerKeyMD5(v string) *CreateMultipartUploadInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *CreateMultipartUploadInput) SetSSEKMSKeyId(v string) *CreateMultipartUploadInput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *CreateMultipartUploadInput) SetServerSideEncryption(v string) *CreateMultipartUploadInput {+ s.ServerSideEncryption = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *CreateMultipartUploadInput) SetStorageClass(v string) *CreateMultipartUploadInput {+ s.StorageClass = &v+ return s+}++// SetTagging sets the Tagging field's value.+func (s *CreateMultipartUploadInput) SetTagging(v string) *CreateMultipartUploadInput {+ s.Tagging = &v+ return s+}++// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.+func (s *CreateMultipartUploadInput) SetWebsiteRedirectLocation(v string) *CreateMultipartUploadInput {+ s.WebsiteRedirectLocation = &v+ return s+}++type CreateMultipartUploadOutput struct {+ _ struct{} `type:"structure"`++ // Date when multipart upload will become eligible for abort operation by lifecycle.+ AbortDate *time.Time `location:"header" locationName:"x-amz-abort-date" type:"timestamp"`++ // Id of the lifecycle rule that makes a multipart upload eligible for abort+ // operation.+ AbortRuleId *string `location:"header" locationName:"x-amz-abort-rule-id" type:"string"`++ // Name of the bucket to which the multipart upload was initiated.+ Bucket *string `locationName:"Bucket" type:"string"`++ // Object key for which the multipart upload was initiated.+ Key *string `min:"1" type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // ID for the initiated multipart upload.+ UploadId *string `type:"string"`+}++// String returns the string representation+func (s CreateMultipartUploadOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s CreateMultipartUploadOutput) GoString() string {+ return s.String()+}++// SetAbortDate sets the AbortDate field's value.+func (s *CreateMultipartUploadOutput) SetAbortDate(v time.Time) *CreateMultipartUploadOutput {+ s.AbortDate = &v+ return s+}++// SetAbortRuleId sets the AbortRuleId field's value.+func (s *CreateMultipartUploadOutput) SetAbortRuleId(v string) *CreateMultipartUploadOutput {+ s.AbortRuleId = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *CreateMultipartUploadOutput) SetBucket(v string) *CreateMultipartUploadOutput {+ s.Bucket = &v+ return s+}++func (s *CreateMultipartUploadOutput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *CreateMultipartUploadOutput) SetKey(v string) *CreateMultipartUploadOutput {+ s.Key = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *CreateMultipartUploadOutput) SetRequestCharged(v string) *CreateMultipartUploadOutput {+ s.RequestCharged = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *CreateMultipartUploadOutput) SetSSECustomerAlgorithm(v string) *CreateMultipartUploadOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *CreateMultipartUploadOutput) SetSSECustomerKeyMD5(v string) *CreateMultipartUploadOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *CreateMultipartUploadOutput) SetSSEKMSKeyId(v string) *CreateMultipartUploadOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *CreateMultipartUploadOutput) SetServerSideEncryption(v string) *CreateMultipartUploadOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *CreateMultipartUploadOutput) SetUploadId(v string) *CreateMultipartUploadOutput {+ s.UploadId = &v+ return s+}++// The container element for specifying the default Object Lock retention settings+// for new objects placed in the specified bucket.+type DefaultRetention struct {+ _ struct{} `type:"structure"`++ // The number of days that you want to specify for the default retention period.+ Days *int64 `type:"integer"`++ // The default Object Lock retention mode you want to apply to new objects placed+ // in the specified bucket.+ Mode *string `type:"string" enum:"ObjectLockRetentionMode"`++ // The number of years that you want to specify for the default retention period.+ Years *int64 `type:"integer"`+}++// String returns the string representation+func (s DefaultRetention) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DefaultRetention) GoString() string {+ return s.String()+}++// SetDays sets the Days field's value.+func (s *DefaultRetention) SetDays(v int64) *DefaultRetention {+ s.Days = &v+ return s+}++// SetMode sets the Mode field's value.+func (s *DefaultRetention) SetMode(v string) *DefaultRetention {+ s.Mode = &v+ return s+}++// SetYears sets the Years field's value.+func (s *DefaultRetention) SetYears(v int64) *DefaultRetention {+ s.Years = &v+ return s+}++type Delete struct {+ _ struct{} `type:"structure"`++ // Objects is a required field+ Objects []*ObjectIdentifier `locationName:"Object" type:"list" flattened:"true" required:"true"`++ // Element to enable quiet mode for the request. When you add this element,+ // you must set its value to true.+ Quiet *bool `type:"boolean"`+}++// String returns the string representation+func (s Delete) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Delete) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Delete) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Delete"}+ if s.Objects == nil {+ invalidParams.Add(request.NewErrParamRequired("Objects"))+ }+ if s.Objects != nil {+ for i, v := range s.Objects {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Objects", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetObjects sets the Objects field's value.+func (s *Delete) SetObjects(v []*ObjectIdentifier) *Delete {+ s.Objects = v+ return s+}++// SetQuiet sets the Quiet field's value.+func (s *Delete) SetQuiet(v bool) *Delete {+ s.Quiet = &v+ return s+}++type DeleteBucketAnalyticsConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket from which an analytics configuration is deleted.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The identifier used to represent an analytics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketAnalyticsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketAnalyticsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketAnalyticsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketAnalyticsConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketAnalyticsConfigurationInput) SetBucket(v string) *DeleteBucketAnalyticsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketAnalyticsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *DeleteBucketAnalyticsConfigurationInput) SetId(v string) *DeleteBucketAnalyticsConfigurationInput {+ s.Id = &v+ return s+}++type DeleteBucketAnalyticsConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketAnalyticsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketAnalyticsConfigurationOutput) GoString() string {+ return s.String()+}++type DeleteBucketCorsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketCorsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketCorsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketCorsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketCorsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketCorsInput) SetBucket(v string) *DeleteBucketCorsInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketCorsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketCorsOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketCorsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketCorsOutput) GoString() string {+ return s.String()+}++type DeleteBucketEncryptionInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the server-side encryption configuration+ // to delete.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketEncryptionInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketEncryptionInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketEncryptionInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketEncryptionInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketEncryptionInput) SetBucket(v string) *DeleteBucketEncryptionInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketEncryptionInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketEncryptionOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketEncryptionOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketEncryptionOutput) GoString() string {+ return s.String()+}++type DeleteBucketInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketInput) SetBucket(v string) *DeleteBucketInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketInventoryConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the inventory configuration to delete.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the inventory configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketInventoryConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketInventoryConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketInventoryConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketInventoryConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketInventoryConfigurationInput) SetBucket(v string) *DeleteBucketInventoryConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketInventoryConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *DeleteBucketInventoryConfigurationInput) SetId(v string) *DeleteBucketInventoryConfigurationInput {+ s.Id = &v+ return s+}++type DeleteBucketInventoryConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketInventoryConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketInventoryConfigurationOutput) GoString() string {+ return s.String()+}++type DeleteBucketLifecycleInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketLifecycleInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketLifecycleInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketLifecycleInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketLifecycleInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketLifecycleInput) SetBucket(v string) *DeleteBucketLifecycleInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketLifecycleInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketLifecycleOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketLifecycleOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketLifecycleOutput) GoString() string {+ return s.String()+}++type DeleteBucketMetricsConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the metrics configuration to delete.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the metrics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketMetricsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketMetricsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketMetricsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketMetricsConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketMetricsConfigurationInput) SetBucket(v string) *DeleteBucketMetricsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketMetricsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *DeleteBucketMetricsConfigurationInput) SetId(v string) *DeleteBucketMetricsConfigurationInput {+ s.Id = &v+ return s+}++type DeleteBucketMetricsConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketMetricsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketMetricsConfigurationOutput) GoString() string {+ return s.String()+}++type DeleteBucketOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketOutput) GoString() string {+ return s.String()+}++type DeleteBucketPolicyInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketPolicyInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketPolicyInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketPolicyInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketPolicyInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketPolicyInput) SetBucket(v string) *DeleteBucketPolicyInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketPolicyInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketPolicyOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketPolicyOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketPolicyOutput) GoString() string {+ return s.String()+}++type DeleteBucketReplicationInput struct {+ _ struct{} `type:"structure"`++ // The bucket name.+ //+ // It can take a while to propagate the deletion of a replication configuration+ // to all Amazon S3 systems.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketReplicationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketReplicationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketReplicationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketReplicationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketReplicationInput) SetBucket(v string) *DeleteBucketReplicationInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketReplicationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketReplicationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketReplicationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketReplicationOutput) GoString() string {+ return s.String()+}++type DeleteBucketTaggingInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketTaggingInput) SetBucket(v string) *DeleteBucketTaggingInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketTaggingOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketTaggingOutput) GoString() string {+ return s.String()+}++type DeleteBucketWebsiteInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeleteBucketWebsiteInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketWebsiteInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteBucketWebsiteInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteBucketWebsiteInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteBucketWebsiteInput) SetBucket(v string) *DeleteBucketWebsiteInput {+ s.Bucket = &v+ return s+}++func (s *DeleteBucketWebsiteInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeleteBucketWebsiteOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeleteBucketWebsiteOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteBucketWebsiteOutput) GoString() string {+ return s.String()+}++type DeleteMarkerEntry struct {+ _ struct{} `type:"structure"`++ // Specifies whether the object is (true) or is not (false) the latest version+ // of an object.+ IsLatest *bool `type:"boolean"`++ // The object key.+ Key *string `min:"1" type:"string"`++ // Date and time the object was last modified.+ LastModified *time.Time `type:"timestamp"`++ Owner *Owner `type:"structure"`++ // Version ID of an object.+ VersionId *string `type:"string"`+}++// String returns the string representation+func (s DeleteMarkerEntry) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteMarkerEntry) GoString() string {+ return s.String()+}++// SetIsLatest sets the IsLatest field's value.+func (s *DeleteMarkerEntry) SetIsLatest(v bool) *DeleteMarkerEntry {+ s.IsLatest = &v+ return s+}++// SetKey sets the Key field's value.+func (s *DeleteMarkerEntry) SetKey(v string) *DeleteMarkerEntry {+ s.Key = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *DeleteMarkerEntry) SetLastModified(v time.Time) *DeleteMarkerEntry {+ s.LastModified = &v+ return s+}++// SetOwner sets the Owner field's value.+func (s *DeleteMarkerEntry) SetOwner(v *Owner) *DeleteMarkerEntry {+ s.Owner = v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *DeleteMarkerEntry) SetVersionId(v string) *DeleteMarkerEntry {+ s.VersionId = &v+ return s+}++// Specifies whether Amazon S3 should replicate delete makers.+type DeleteMarkerReplication struct {+ _ struct{} `type:"structure"`++ // The status of the delete marker replication.+ //+ // In the current implementation, Amazon S3 doesn't replicate the delete markers.+ // The status must be Disabled.+ Status *string `type:"string" enum:"DeleteMarkerReplicationStatus"`+}++// String returns the string representation+func (s DeleteMarkerReplication) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteMarkerReplication) GoString() string {+ return s.String()+}++// SetStatus sets the Status field's value.+func (s *DeleteMarkerReplication) SetStatus(v string) *DeleteMarkerReplication {+ s.Status = &v+ return s+}++type DeleteObjectInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Indicates whether S3 Object Lock should bypass Governance-mode restrictions+ // to process this operation.+ BypassGovernanceRetention *bool `location:"header" locationName:"x-amz-bypass-governance-retention" type:"boolean"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // The concatenation of the authentication device's serial number, a space,+ // and the value that is displayed on your authentication device.+ MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`++ // 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" enum:"RequestPayer"`++ // VersionId used to reference a specific version of the object.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s DeleteObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteObjectInput) SetBucket(v string) *DeleteObjectInput {+ s.Bucket = &v+ return s+}++func (s *DeleteObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetBypassGovernanceRetention sets the BypassGovernanceRetention field's value.+func (s *DeleteObjectInput) SetBypassGovernanceRetention(v bool) *DeleteObjectInput {+ s.BypassGovernanceRetention = &v+ return s+}++// SetKey sets the Key field's value.+func (s *DeleteObjectInput) SetKey(v string) *DeleteObjectInput {+ s.Key = &v+ return s+}++// SetMFA sets the MFA field's value.+func (s *DeleteObjectInput) SetMFA(v string) *DeleteObjectInput {+ s.MFA = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *DeleteObjectInput) SetRequestPayer(v string) *DeleteObjectInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *DeleteObjectInput) SetVersionId(v string) *DeleteObjectInput {+ s.VersionId = &v+ return s+}++type DeleteObjectOutput struct {+ _ struct{} `type:"structure"`++ // Specifies whether the versioned object that was permanently deleted was (true)+ // or was not (false) a delete marker.+ DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // Returns the version ID of the delete marker created as a result of the DELETE+ // operation.+ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s DeleteObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectOutput) GoString() string {+ return s.String()+}++// SetDeleteMarker sets the DeleteMarker field's value.+func (s *DeleteObjectOutput) SetDeleteMarker(v bool) *DeleteObjectOutput {+ s.DeleteMarker = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *DeleteObjectOutput) SetRequestCharged(v string) *DeleteObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *DeleteObjectOutput) SetVersionId(v string) *DeleteObjectOutput {+ s.VersionId = &v+ return s+}++type DeleteObjectTaggingInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // The versionId of the object that the tag-set will be removed from.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s DeleteObjectTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteObjectTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteObjectTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteObjectTaggingInput) SetBucket(v string) *DeleteObjectTaggingInput {+ s.Bucket = &v+ return s+}++func (s *DeleteObjectTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *DeleteObjectTaggingInput) SetKey(v string) *DeleteObjectTaggingInput {+ s.Key = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *DeleteObjectTaggingInput) SetVersionId(v string) *DeleteObjectTaggingInput {+ s.VersionId = &v+ return s+}++type DeleteObjectTaggingOutput struct {+ _ struct{} `type:"structure"`++ // The versionId of the object the tag-set was removed from.+ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s DeleteObjectTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectTaggingOutput) GoString() string {+ return s.String()+}++// SetVersionId sets the VersionId field's value.+func (s *DeleteObjectTaggingOutput) SetVersionId(v string) *DeleteObjectTaggingOutput {+ s.VersionId = &v+ return s+}++type DeleteObjectsInput struct {+ _ struct{} `type:"structure" payload:"Delete"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Specifies whether you want to delete this object even if it has a Governance-type+ // Object Lock in place. You must have sufficient permissions to perform this+ // operation.+ BypassGovernanceRetention *bool `location:"header" locationName:"x-amz-bypass-governance-retention" type:"boolean"`++ // Delete is a required field+ Delete *Delete `locationName:"Delete" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // The concatenation of the authentication device's serial number, a space,+ // and the value that is displayed on your authentication device.+ MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`++ // 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" enum:"RequestPayer"`+}++// String returns the string representation+func (s DeleteObjectsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeleteObjectsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeleteObjectsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Delete == nil {+ invalidParams.Add(request.NewErrParamRequired("Delete"))+ }+ if s.Delete != nil {+ if err := s.Delete.Validate(); err != nil {+ invalidParams.AddNested("Delete", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeleteObjectsInput) SetBucket(v string) *DeleteObjectsInput {+ s.Bucket = &v+ return s+}++func (s *DeleteObjectsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetBypassGovernanceRetention sets the BypassGovernanceRetention field's value.+func (s *DeleteObjectsInput) SetBypassGovernanceRetention(v bool) *DeleteObjectsInput {+ s.BypassGovernanceRetention = &v+ return s+}++// SetDelete sets the Delete field's value.+func (s *DeleteObjectsInput) SetDelete(v *Delete) *DeleteObjectsInput {+ s.Delete = v+ return s+}++// SetMFA sets the MFA field's value.+func (s *DeleteObjectsInput) SetMFA(v string) *DeleteObjectsInput {+ s.MFA = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *DeleteObjectsInput) SetRequestPayer(v string) *DeleteObjectsInput {+ s.RequestPayer = &v+ return s+}++type DeleteObjectsOutput struct {+ _ struct{} `type:"structure"`++ Deleted []*DeletedObject `type:"list" flattened:"true"`++ Errors []*Error `locationName:"Error" type:"list" flattened:"true"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s DeleteObjectsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeleteObjectsOutput) GoString() string {+ return s.String()+}++// SetDeleted sets the Deleted field's value.+func (s *DeleteObjectsOutput) SetDeleted(v []*DeletedObject) *DeleteObjectsOutput {+ s.Deleted = v+ return s+}++// SetErrors sets the Errors field's value.+func (s *DeleteObjectsOutput) SetErrors(v []*Error) *DeleteObjectsOutput {+ s.Errors = v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *DeleteObjectsOutput) SetRequestCharged(v string) *DeleteObjectsOutput {+ s.RequestCharged = &v+ return s+}++type DeletePublicAccessBlockInput struct {+ _ struct{} `type:"structure"`++ // The Amazon S3 bucket whose PublicAccessBlock configuration you want to delete.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s DeletePublicAccessBlockInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeletePublicAccessBlockInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DeletePublicAccessBlockInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DeletePublicAccessBlockInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *DeletePublicAccessBlockInput) SetBucket(v string) *DeletePublicAccessBlockInput {+ s.Bucket = &v+ return s+}++func (s *DeletePublicAccessBlockInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type DeletePublicAccessBlockOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s DeletePublicAccessBlockOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeletePublicAccessBlockOutput) GoString() string {+ return s.String()+}++type DeletedObject struct {+ _ struct{} `type:"structure"`++ DeleteMarker *bool `type:"boolean"`++ DeleteMarkerVersionId *string `type:"string"`++ Key *string `min:"1" type:"string"`++ VersionId *string `type:"string"`+}++// String returns the string representation+func (s DeletedObject) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DeletedObject) GoString() string {+ return s.String()+}++// SetDeleteMarker sets the DeleteMarker field's value.+func (s *DeletedObject) SetDeleteMarker(v bool) *DeletedObject {+ s.DeleteMarker = &v+ return s+}++// SetDeleteMarkerVersionId sets the DeleteMarkerVersionId field's value.+func (s *DeletedObject) SetDeleteMarkerVersionId(v string) *DeletedObject {+ s.DeleteMarkerVersionId = &v+ return s+}++// SetKey sets the Key field's value.+func (s *DeletedObject) SetKey(v string) *DeletedObject {+ s.Key = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *DeletedObject) SetVersionId(v string) *DeletedObject {+ s.VersionId = &v+ return s+}++// A container for information about the replication destination.+type Destination struct {+ _ struct{} `type:"structure"`++ // A container for information about access control for replicas.+ //+ // Use this element only in a cross-account scenario where source and destination+ // bucket owners are not the same to change replica ownership to the AWS account+ // that owns the destination bucket. If you don't add this element to the replication+ // configuration, the replicas are owned by same AWS account that owns the source+ // object.+ AccessControlTranslation *AccessControlTranslation `type:"structure"`++ // The account ID of the destination bucket. Currently, Amazon S3 verifies this+ // value only if Access Control Translation is enabled.+ //+ // In a cross-account scenario, if you change replica ownership to the AWS account+ // that owns the destination bucket by adding the AccessControlTranslation element,+ // this is the account ID of the owner of the destination bucket.+ Account *string `type:"string"`++ // The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to+ // store replicas of the object identified by the rule.+ //+ // If there are multiple rules in your replication configuration, all rules+ // must specify the same bucket as the destination. A replication configuration+ // can replicate objects to only one destination bucket.+ //+ // Bucket is a required field+ Bucket *string `type:"string" required:"true"`++ // A container that provides information about encryption. If SourceSelectionCriteria+ // is specified, you must specify this element.+ EncryptionConfiguration *EncryptionConfiguration `type:"structure"`++ // The class of storage used to store the object. By default Amazon S3 uses+ // storage class of the source object when creating a replica.+ StorageClass *string `type:"string" enum:"StorageClass"`+}++// String returns the string representation+func (s Destination) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Destination) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Destination) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Destination"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.AccessControlTranslation != nil {+ if err := s.AccessControlTranslation.Validate(); err != nil {+ invalidParams.AddNested("AccessControlTranslation", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAccessControlTranslation sets the AccessControlTranslation field's value.+func (s *Destination) SetAccessControlTranslation(v *AccessControlTranslation) *Destination {+ s.AccessControlTranslation = v+ return s+}++// SetAccount sets the Account field's value.+func (s *Destination) SetAccount(v string) *Destination {+ s.Account = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *Destination) SetBucket(v string) *Destination {+ s.Bucket = &v+ return s+}++func (s *Destination) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetEncryptionConfiguration sets the EncryptionConfiguration field's value.+func (s *Destination) SetEncryptionConfiguration(v *EncryptionConfiguration) *Destination {+ s.EncryptionConfiguration = v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *Destination) SetStorageClass(v string) *Destination {+ s.StorageClass = &v+ return s+}++// Describes the server-side encryption that will be applied to the restore+// results.+type Encryption struct {+ _ struct{} `type:"structure"`++ // The server-side encryption algorithm used when storing job results in Amazon+ // S3 (e.g., AES256, aws:kms).+ //+ // EncryptionType is a required field+ EncryptionType *string `type:"string" required:"true" enum:"ServerSideEncryption"`++ // If the encryption type is aws:kms, this optional value can be used to specify+ // the encryption context for the restore results.+ KMSContext *string `type:"string"`++ // If the encryption type is aws:kms, this optional value specifies the AWS+ // KMS key ID to use for encryption of job results.+ KMSKeyId *string `type:"string" sensitive:"true"`+}++// String returns the string representation+func (s Encryption) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Encryption) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Encryption) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Encryption"}+ if s.EncryptionType == nil {+ invalidParams.Add(request.NewErrParamRequired("EncryptionType"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetEncryptionType sets the EncryptionType field's value.+func (s *Encryption) SetEncryptionType(v string) *Encryption {+ s.EncryptionType = &v+ return s+}++// SetKMSContext sets the KMSContext field's value.+func (s *Encryption) SetKMSContext(v string) *Encryption {+ s.KMSContext = &v+ return s+}++// SetKMSKeyId sets the KMSKeyId field's value.+func (s *Encryption) SetKMSKeyId(v string) *Encryption {+ s.KMSKeyId = &v+ return s+}++// A container for information about the encryption-based configuration for+// replicas.+type EncryptionConfiguration struct {+ _ struct{} `type:"structure"`++ // The ID of the AWS KMS key for the AWS Region where the destination bucket+ // resides. Amazon S3 uses this key to encrypt the replica object.+ ReplicaKmsKeyID *string `type:"string"`+}++// String returns the string representation+func (s EncryptionConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s EncryptionConfiguration) GoString() string {+ return s.String()+}++// SetReplicaKmsKeyID sets the ReplicaKmsKeyID field's value.+func (s *EncryptionConfiguration) SetReplicaKmsKeyID(v string) *EncryptionConfiguration {+ s.ReplicaKmsKeyID = &v+ return s+}++type EndEvent struct {+ _ struct{} `locationName:"EndEvent" type:"structure"`+}++// String returns the string representation+func (s EndEvent) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s EndEvent) GoString() string {+ return s.String()+}++// The EndEvent is and event in the SelectObjectContentEventStream group of events.+func (s *EndEvent) eventSelectObjectContentEventStream() {}++// UnmarshalEvent unmarshals the EventStream Message into the EndEvent value.+// This method is only used internally within the SDK's EventStream handling.+func (s *EndEvent) UnmarshalEvent(+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ msg eventstream.Message,+) error {+ return nil+}++type Error struct {+ _ struct{} `type:"structure"`++ Code *string `type:"string"`++ Key *string `min:"1" type:"string"`++ Message *string `type:"string"`++ VersionId *string `type:"string"`+}++// String returns the string representation+func (s Error) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Error) GoString() string {+ return s.String()+}++// SetCode sets the Code field's value.+func (s *Error) SetCode(v string) *Error {+ s.Code = &v+ return s+}++// SetKey sets the Key field's value.+func (s *Error) SetKey(v string) *Error {+ s.Key = &v+ return s+}++// SetMessage sets the Message field's value.+func (s *Error) SetMessage(v string) *Error {+ s.Message = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *Error) SetVersionId(v string) *Error {+ s.VersionId = &v+ return s+}++type ErrorDocument struct {+ _ struct{} `type:"structure"`++ // The object key name to use when a 4XX class error occurs.+ //+ // Key is a required field+ Key *string `min:"1" type:"string" required:"true"`+}++// String returns the string representation+func (s ErrorDocument) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ErrorDocument) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ErrorDocument) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ErrorDocument"}+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetKey sets the Key field's value.+func (s *ErrorDocument) SetKey(v string) *ErrorDocument {+ s.Key = &v+ return s+}++// A container for a key value pair that defines the criteria for the filter+// rule.+type FilterRule struct {+ _ struct{} `type:"structure"`++ // The object key name prefix or suffix identifying one or more objects to which+ // the filtering rule applies. The maximum prefix length is 1,024 characters.+ // Overlapping prefixes and suffixes are not supported. For more information,+ // see Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)+ // in the Amazon Simple Storage Service Developer Guide.+ Name *string `type:"string" enum:"FilterRuleName"`++ Value *string `type:"string"`+}++// String returns the string representation+func (s FilterRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s FilterRule) GoString() string {+ return s.String()+}++// SetName sets the Name field's value.+func (s *FilterRule) SetName(v string) *FilterRule {+ s.Name = &v+ return s+}++// SetValue sets the Value field's value.+func (s *FilterRule) SetValue(v string) *FilterRule {+ s.Value = &v+ return s+}++type GetBucketAccelerateConfigurationInput struct {+ _ struct{} `type:"structure"`++ // Name of the bucket for which the accelerate configuration is retrieved.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketAccelerateConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAccelerateConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketAccelerateConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketAccelerateConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketAccelerateConfigurationInput) SetBucket(v string) *GetBucketAccelerateConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketAccelerateConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketAccelerateConfigurationOutput struct {+ _ struct{} `type:"structure"`++ // The accelerate configuration of the bucket.+ Status *string `type:"string" enum:"BucketAccelerateStatus"`+}++// String returns the string representation+func (s GetBucketAccelerateConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAccelerateConfigurationOutput) GoString() string {+ return s.String()+}++// SetStatus sets the Status field's value.+func (s *GetBucketAccelerateConfigurationOutput) SetStatus(v string) *GetBucketAccelerateConfigurationOutput {+ s.Status = &v+ return s+}++type GetBucketAclInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketAclInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAclInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketAclInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketAclInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketAclInput) SetBucket(v string) *GetBucketAclInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketAclInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketAclOutput struct {+ _ struct{} `type:"structure"`++ // A list of grants.+ Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`++ Owner *Owner `type:"structure"`+}++// String returns the string representation+func (s GetBucketAclOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAclOutput) GoString() string {+ return s.String()+}++// SetGrants sets the Grants field's value.+func (s *GetBucketAclOutput) SetGrants(v []*Grant) *GetBucketAclOutput {+ s.Grants = v+ return s+}++// SetOwner sets the Owner field's value.+func (s *GetBucketAclOutput) SetOwner(v *Owner) *GetBucketAclOutput {+ s.Owner = v+ return s+}++type GetBucketAnalyticsConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket from which an analytics configuration is retrieved.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The identifier used to represent an analytics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketAnalyticsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAnalyticsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketAnalyticsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketAnalyticsConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketAnalyticsConfigurationInput) SetBucket(v string) *GetBucketAnalyticsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketAnalyticsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *GetBucketAnalyticsConfigurationInput) SetId(v string) *GetBucketAnalyticsConfigurationInput {+ s.Id = &v+ return s+}++type GetBucketAnalyticsConfigurationOutput struct {+ _ struct{} `type:"structure" payload:"AnalyticsConfiguration"`++ // The configuration and any analyses for the analytics filter.+ AnalyticsConfiguration *AnalyticsConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetBucketAnalyticsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketAnalyticsConfigurationOutput) GoString() string {+ return s.String()+}++// SetAnalyticsConfiguration sets the AnalyticsConfiguration field's value.+func (s *GetBucketAnalyticsConfigurationOutput) SetAnalyticsConfiguration(v *AnalyticsConfiguration) *GetBucketAnalyticsConfigurationOutput {+ s.AnalyticsConfiguration = v+ return s+}++type GetBucketCorsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketCorsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketCorsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketCorsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketCorsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketCorsInput) SetBucket(v string) *GetBucketCorsInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketCorsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketCorsOutput struct {+ _ struct{} `type:"structure"`++ CORSRules []*CORSRule `locationName:"CORSRule" type:"list" flattened:"true"`+}++// String returns the string representation+func (s GetBucketCorsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketCorsOutput) GoString() string {+ return s.String()+}++// SetCORSRules sets the CORSRules field's value.+func (s *GetBucketCorsOutput) SetCORSRules(v []*CORSRule) *GetBucketCorsOutput {+ s.CORSRules = v+ return s+}++type GetBucketEncryptionInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket from which the server-side encryption configuration+ // is retrieved.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketEncryptionInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketEncryptionInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketEncryptionInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketEncryptionInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketEncryptionInput) SetBucket(v string) *GetBucketEncryptionInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketEncryptionInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketEncryptionOutput struct {+ _ struct{} `type:"structure" payload:"ServerSideEncryptionConfiguration"`++ // Container for server-side encryption configuration rules. Currently S3 supports+ // one rule only.+ ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetBucketEncryptionOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketEncryptionOutput) GoString() string {+ return s.String()+}++// SetServerSideEncryptionConfiguration sets the ServerSideEncryptionConfiguration field's value.+func (s *GetBucketEncryptionOutput) SetServerSideEncryptionConfiguration(v *ServerSideEncryptionConfiguration) *GetBucketEncryptionOutput {+ s.ServerSideEncryptionConfiguration = v+ return s+}++type GetBucketInventoryConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the inventory configuration to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the inventory configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketInventoryConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketInventoryConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketInventoryConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketInventoryConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketInventoryConfigurationInput) SetBucket(v string) *GetBucketInventoryConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketInventoryConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *GetBucketInventoryConfigurationInput) SetId(v string) *GetBucketInventoryConfigurationInput {+ s.Id = &v+ return s+}++type GetBucketInventoryConfigurationOutput struct {+ _ struct{} `type:"structure" payload:"InventoryConfiguration"`++ // Specifies the inventory configuration.+ InventoryConfiguration *InventoryConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetBucketInventoryConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketInventoryConfigurationOutput) GoString() string {+ return s.String()+}++// SetInventoryConfiguration sets the InventoryConfiguration field's value.+func (s *GetBucketInventoryConfigurationOutput) SetInventoryConfiguration(v *InventoryConfiguration) *GetBucketInventoryConfigurationOutput {+ s.InventoryConfiguration = v+ return s+}++type GetBucketLifecycleConfigurationInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketLifecycleConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLifecycleConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketLifecycleConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketLifecycleConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketLifecycleConfigurationInput) SetBucket(v string) *GetBucketLifecycleConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketLifecycleConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketLifecycleConfigurationOutput struct {+ _ struct{} `type:"structure"`++ Rules []*LifecycleRule `locationName:"Rule" type:"list" flattened:"true"`+}++// String returns the string representation+func (s GetBucketLifecycleConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLifecycleConfigurationOutput) GoString() string {+ return s.String()+}++// SetRules sets the Rules field's value.+func (s *GetBucketLifecycleConfigurationOutput) SetRules(v []*LifecycleRule) *GetBucketLifecycleConfigurationOutput {+ s.Rules = v+ return s+}++type GetBucketLifecycleInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketLifecycleInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLifecycleInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketLifecycleInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketLifecycleInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketLifecycleInput) SetBucket(v string) *GetBucketLifecycleInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketLifecycleInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketLifecycleOutput struct {+ _ struct{} `type:"structure"`++ Rules []*Rule `locationName:"Rule" type:"list" flattened:"true"`+}++// String returns the string representation+func (s GetBucketLifecycleOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLifecycleOutput) GoString() string {+ return s.String()+}++// SetRules sets the Rules field's value.+func (s *GetBucketLifecycleOutput) SetRules(v []*Rule) *GetBucketLifecycleOutput {+ s.Rules = v+ return s+}++type GetBucketLocationInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketLocationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLocationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketLocationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketLocationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketLocationInput) SetBucket(v string) *GetBucketLocationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketLocationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketLocationOutput struct {+ _ struct{} `type:"structure"`++ LocationConstraint *string `type:"string" enum:"BucketLocationConstraint"`+}++// String returns the string representation+func (s GetBucketLocationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLocationOutput) GoString() string {+ return s.String()+}++// SetLocationConstraint sets the LocationConstraint field's value.+func (s *GetBucketLocationOutput) SetLocationConstraint(v string) *GetBucketLocationOutput {+ s.LocationConstraint = &v+ return s+}++type GetBucketLoggingInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketLoggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLoggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketLoggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketLoggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketLoggingInput) SetBucket(v string) *GetBucketLoggingInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketLoggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketLoggingOutput struct {+ _ struct{} `type:"structure"`++ // Container for logging information. Presence of this element indicates that+ // logging is enabled. Parameters TargetBucket and TargetPrefix are required+ // in this case.+ LoggingEnabled *LoggingEnabled `type:"structure"`+}++// String returns the string representation+func (s GetBucketLoggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketLoggingOutput) GoString() string {+ return s.String()+}++// SetLoggingEnabled sets the LoggingEnabled field's value.+func (s *GetBucketLoggingOutput) SetLoggingEnabled(v *LoggingEnabled) *GetBucketLoggingOutput {+ s.LoggingEnabled = v+ return s+}++type GetBucketMetricsConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the metrics configuration to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the metrics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketMetricsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketMetricsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketMetricsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketMetricsConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketMetricsConfigurationInput) SetBucket(v string) *GetBucketMetricsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketMetricsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *GetBucketMetricsConfigurationInput) SetId(v string) *GetBucketMetricsConfigurationInput {+ s.Id = &v+ return s+}++type GetBucketMetricsConfigurationOutput struct {+ _ struct{} `type:"structure" payload:"MetricsConfiguration"`++ // Specifies the metrics configuration.+ MetricsConfiguration *MetricsConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetBucketMetricsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketMetricsConfigurationOutput) GoString() string {+ return s.String()+}++// SetMetricsConfiguration sets the MetricsConfiguration field's value.+func (s *GetBucketMetricsConfigurationOutput) SetMetricsConfiguration(v *MetricsConfiguration) *GetBucketMetricsConfigurationOutput {+ s.MetricsConfiguration = v+ return s+}++type GetBucketNotificationConfigurationRequest struct {+ _ struct{} `type:"structure"`++ // Name of the bucket to get the notification configuration for.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketNotificationConfigurationRequest) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketNotificationConfigurationRequest) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketNotificationConfigurationRequest) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketNotificationConfigurationRequest"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketNotificationConfigurationRequest) SetBucket(v string) *GetBucketNotificationConfigurationRequest {+ s.Bucket = &v+ return s+}++func (s *GetBucketNotificationConfigurationRequest) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketPolicyInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketPolicyInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketPolicyInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketPolicyInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketPolicyInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketPolicyInput) SetBucket(v string) *GetBucketPolicyInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketPolicyInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketPolicyOutput struct {+ _ struct{} `type:"structure" payload:"Policy"`++ // The bucket policy as a JSON document.+ Policy *string `type:"string"`+}++// String returns the string representation+func (s GetBucketPolicyOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketPolicyOutput) GoString() string {+ return s.String()+}++// SetPolicy sets the Policy field's value.+func (s *GetBucketPolicyOutput) SetPolicy(v string) *GetBucketPolicyOutput {+ s.Policy = &v+ return s+}++type GetBucketPolicyStatusInput struct {+ _ struct{} `type:"structure"`++ // The name of the Amazon S3 bucket whose policy status you want to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketPolicyStatusInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketPolicyStatusInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketPolicyStatusInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketPolicyStatusInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketPolicyStatusInput) SetBucket(v string) *GetBucketPolicyStatusInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketPolicyStatusInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketPolicyStatusOutput struct {+ _ struct{} `type:"structure" payload:"PolicyStatus"`++ // The policy status for the specified bucket.+ PolicyStatus *PolicyStatus `type:"structure"`+}++// String returns the string representation+func (s GetBucketPolicyStatusOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketPolicyStatusOutput) GoString() string {+ return s.String()+}++// SetPolicyStatus sets the PolicyStatus field's value.+func (s *GetBucketPolicyStatusOutput) SetPolicyStatus(v *PolicyStatus) *GetBucketPolicyStatusOutput {+ s.PolicyStatus = v+ return s+}++type GetBucketReplicationInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketReplicationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketReplicationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketReplicationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketReplicationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketReplicationInput) SetBucket(v string) *GetBucketReplicationInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketReplicationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketReplicationOutput struct {+ _ struct{} `type:"structure" payload:"ReplicationConfiguration"`++ // A container for replication rules. You can add up to 1,000 rules. The maximum+ // size of a replication configuration is 2 MB.+ ReplicationConfiguration *ReplicationConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetBucketReplicationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketReplicationOutput) GoString() string {+ return s.String()+}++// SetReplicationConfiguration sets the ReplicationConfiguration field's value.+func (s *GetBucketReplicationOutput) SetReplicationConfiguration(v *ReplicationConfiguration) *GetBucketReplicationOutput {+ s.ReplicationConfiguration = v+ return s+}++type GetBucketRequestPaymentInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketRequestPaymentInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketRequestPaymentInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketRequestPaymentInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketRequestPaymentInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketRequestPaymentInput) SetBucket(v string) *GetBucketRequestPaymentInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketRequestPaymentInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketRequestPaymentOutput struct {+ _ struct{} `type:"structure"`++ // Specifies who pays for the download and request fees.+ Payer *string `type:"string" enum:"Payer"`+}++// String returns the string representation+func (s GetBucketRequestPaymentOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketRequestPaymentOutput) GoString() string {+ return s.String()+}++// SetPayer sets the Payer field's value.+func (s *GetBucketRequestPaymentOutput) SetPayer(v string) *GetBucketRequestPaymentOutput {+ s.Payer = &v+ return s+}++type GetBucketTaggingInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketTaggingInput) SetBucket(v string) *GetBucketTaggingInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketTaggingOutput struct {+ _ struct{} `type:"structure"`++ // TagSet is a required field+ TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`+}++// String returns the string representation+func (s GetBucketTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketTaggingOutput) GoString() string {+ return s.String()+}++// SetTagSet sets the TagSet field's value.+func (s *GetBucketTaggingOutput) SetTagSet(v []*Tag) *GetBucketTaggingOutput {+ s.TagSet = v+ return s+}++type GetBucketVersioningInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketVersioningInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketVersioningInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketVersioningInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketVersioningInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketVersioningInput) SetBucket(v string) *GetBucketVersioningInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketVersioningInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketVersioningOutput struct {+ _ struct{} `type:"structure"`++ // Specifies whether MFA delete is enabled in the bucket versioning configuration.+ // This element is only returned if the bucket has been configured with MFA+ // delete. If the bucket has never been so configured, this element is not returned.+ MFADelete *string `locationName:"MfaDelete" type:"string" enum:"MFADeleteStatus"`++ // The versioning state of the bucket.+ Status *string `type:"string" enum:"BucketVersioningStatus"`+}++// String returns the string representation+func (s GetBucketVersioningOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketVersioningOutput) GoString() string {+ return s.String()+}++// SetMFADelete sets the MFADelete field's value.+func (s *GetBucketVersioningOutput) SetMFADelete(v string) *GetBucketVersioningOutput {+ s.MFADelete = &v+ return s+}++// SetStatus sets the Status field's value.+func (s *GetBucketVersioningOutput) SetStatus(v string) *GetBucketVersioningOutput {+ s.Status = &v+ return s+}++type GetBucketWebsiteInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetBucketWebsiteInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketWebsiteInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetBucketWebsiteInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetBucketWebsiteInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetBucketWebsiteInput) SetBucket(v string) *GetBucketWebsiteInput {+ s.Bucket = &v+ return s+}++func (s *GetBucketWebsiteInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetBucketWebsiteOutput struct {+ _ struct{} `type:"structure"`++ ErrorDocument *ErrorDocument `type:"structure"`++ IndexDocument *IndexDocument `type:"structure"`++ RedirectAllRequestsTo *RedirectAllRequestsTo `type:"structure"`++ RoutingRules []*RoutingRule `locationNameList:"RoutingRule" type:"list"`+}++// String returns the string representation+func (s GetBucketWebsiteOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetBucketWebsiteOutput) GoString() string {+ return s.String()+}++// SetErrorDocument sets the ErrorDocument field's value.+func (s *GetBucketWebsiteOutput) SetErrorDocument(v *ErrorDocument) *GetBucketWebsiteOutput {+ s.ErrorDocument = v+ return s+}++// SetIndexDocument sets the IndexDocument field's value.+func (s *GetBucketWebsiteOutput) SetIndexDocument(v *IndexDocument) *GetBucketWebsiteOutput {+ s.IndexDocument = v+ return s+}++// SetRedirectAllRequestsTo sets the RedirectAllRequestsTo field's value.+func (s *GetBucketWebsiteOutput) SetRedirectAllRequestsTo(v *RedirectAllRequestsTo) *GetBucketWebsiteOutput {+ s.RedirectAllRequestsTo = v+ return s+}++// SetRoutingRules sets the RoutingRules field's value.+func (s *GetBucketWebsiteOutput) SetRoutingRules(v []*RoutingRule) *GetBucketWebsiteOutput {+ s.RoutingRules = v+ return s+}++type GetObjectAclInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // VersionId used to reference a specific version of the object.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s GetObjectAclInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectAclInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectAclInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectAclInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectAclInput) SetBucket(v string) *GetObjectAclInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectAclInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *GetObjectAclInput) SetKey(v string) *GetObjectAclInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *GetObjectAclInput) SetRequestPayer(v string) *GetObjectAclInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectAclInput) SetVersionId(v string) *GetObjectAclInput {+ s.VersionId = &v+ return s+}++type GetObjectAclOutput struct {+ _ struct{} `type:"structure"`++ // A list of grants.+ Grants []*Grant `locationName:"AccessControlList" locationNameList:"Grant" type:"list"`++ Owner *Owner `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s GetObjectAclOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectAclOutput) GoString() string {+ return s.String()+}++// SetGrants sets the Grants field's value.+func (s *GetObjectAclOutput) SetGrants(v []*Grant) *GetObjectAclOutput {+ s.Grants = v+ return s+}++// SetOwner sets the Owner field's value.+func (s *GetObjectAclOutput) SetOwner(v *Owner) *GetObjectAclOutput {+ s.Owner = v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *GetObjectAclOutput) SetRequestCharged(v string) *GetObjectAclOutput {+ s.RequestCharged = &v+ return s+}++type GetObjectInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Return the object only if its entity tag (ETag) is the same as the one specified,+ // otherwise return a 412 (precondition failed).+ IfMatch *string `location:"header" locationName:"If-Match" type:"string"`++ // Return the object only if it has been modified since the specified time,+ // otherwise return a 304 (not modified).+ IfModifiedSince *time.Time `location:"header" locationName:"If-Modified-Since" type:"timestamp"`++ // Return the object only if its entity tag (ETag) is different from the one+ // specified, otherwise return a 304 (not modified).+ IfNoneMatch *string `location:"header" locationName:"If-None-Match" type:"string"`++ // Return the object only if it has not been modified since the specified time,+ // otherwise return a 412 (precondition failed).+ IfUnmodifiedSince *time.Time `location:"header" locationName:"If-Unmodified-Since" type:"timestamp"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Part number of the object being read. This is a positive integer between+ // 1 and 10,000. Effectively performs a 'ranged' GET request for the part specified.+ // Useful for downloading just a part of an object.+ PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer"`++ // Downloads the specified range bytes of an object. For more information about+ // the HTTP Range header, go to http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.+ Range *string `location:"header" locationName:"Range" type:"string"`++ // 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" enum:"RequestPayer"`++ // Sets the Cache-Control header of the response.+ ResponseCacheControl *string `location:"querystring" locationName:"response-cache-control" type:"string"`++ // Sets the Content-Disposition header of the response+ ResponseContentDisposition *string `location:"querystring" locationName:"response-content-disposition" type:"string"`++ // Sets the Content-Encoding header of the response.+ ResponseContentEncoding *string `location:"querystring" locationName:"response-content-encoding" type:"string"`++ // Sets the Content-Language header of the response.+ ResponseContentLanguage *string `location:"querystring" locationName:"response-content-language" type:"string"`++ // Sets the Content-Type header of the response.+ ResponseContentType *string `location:"querystring" locationName:"response-content-type" type:"string"`++ // Sets the Expires header of the response.+ ResponseExpires *time.Time `location:"querystring" locationName:"response-expires" type:"timestamp"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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" sensitive:"true"`++ // 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"`++ // VersionId used to reference a specific version of the object.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s GetObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectInput) SetBucket(v string) *GetObjectInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetIfMatch sets the IfMatch field's value.+func (s *GetObjectInput) SetIfMatch(v string) *GetObjectInput {+ s.IfMatch = &v+ return s+}++// SetIfModifiedSince sets the IfModifiedSince field's value.+func (s *GetObjectInput) SetIfModifiedSince(v time.Time) *GetObjectInput {+ s.IfModifiedSince = &v+ return s+}++// SetIfNoneMatch sets the IfNoneMatch field's value.+func (s *GetObjectInput) SetIfNoneMatch(v string) *GetObjectInput {+ s.IfNoneMatch = &v+ return s+}++// SetIfUnmodifiedSince sets the IfUnmodifiedSince field's value.+func (s *GetObjectInput) SetIfUnmodifiedSince(v time.Time) *GetObjectInput {+ s.IfUnmodifiedSince = &v+ return s+}++// SetKey sets the Key field's value.+func (s *GetObjectInput) SetKey(v string) *GetObjectInput {+ s.Key = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *GetObjectInput) SetPartNumber(v int64) *GetObjectInput {+ s.PartNumber = &v+ return s+}++// SetRange sets the Range field's value.+func (s *GetObjectInput) SetRange(v string) *GetObjectInput {+ s.Range = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *GetObjectInput) SetRequestPayer(v string) *GetObjectInput {+ s.RequestPayer = &v+ return s+}++// SetResponseCacheControl sets the ResponseCacheControl field's value.+func (s *GetObjectInput) SetResponseCacheControl(v string) *GetObjectInput {+ s.ResponseCacheControl = &v+ return s+}++// SetResponseContentDisposition sets the ResponseContentDisposition field's value.+func (s *GetObjectInput) SetResponseContentDisposition(v string) *GetObjectInput {+ s.ResponseContentDisposition = &v+ return s+}++// SetResponseContentEncoding sets the ResponseContentEncoding field's value.+func (s *GetObjectInput) SetResponseContentEncoding(v string) *GetObjectInput {+ s.ResponseContentEncoding = &v+ return s+}++// SetResponseContentLanguage sets the ResponseContentLanguage field's value.+func (s *GetObjectInput) SetResponseContentLanguage(v string) *GetObjectInput {+ s.ResponseContentLanguage = &v+ return s+}++// SetResponseContentType sets the ResponseContentType field's value.+func (s *GetObjectInput) SetResponseContentType(v string) *GetObjectInput {+ s.ResponseContentType = &v+ return s+}++// SetResponseExpires sets the ResponseExpires field's value.+func (s *GetObjectInput) SetResponseExpires(v time.Time) *GetObjectInput {+ s.ResponseExpires = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *GetObjectInput) SetSSECustomerAlgorithm(v string) *GetObjectInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *GetObjectInput) SetSSECustomerKey(v string) *GetObjectInput {+ s.SSECustomerKey = &v+ return s+}++func (s *GetObjectInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *GetObjectInput) SetSSECustomerKeyMD5(v string) *GetObjectInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectInput) SetVersionId(v string) *GetObjectInput {+ s.VersionId = &v+ return s+}++type GetObjectLegalHoldInput struct {+ _ struct{} `type:"structure"`++ // The bucket containing the object whose Legal Hold status you want to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The key name for the object whose Legal Hold status you want to retrieve.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // The version ID of the object whose Legal Hold status you want to retrieve.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s GetObjectLegalHoldInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectLegalHoldInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectLegalHoldInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectLegalHoldInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectLegalHoldInput) SetBucket(v string) *GetObjectLegalHoldInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectLegalHoldInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *GetObjectLegalHoldInput) SetKey(v string) *GetObjectLegalHoldInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *GetObjectLegalHoldInput) SetRequestPayer(v string) *GetObjectLegalHoldInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectLegalHoldInput) SetVersionId(v string) *GetObjectLegalHoldInput {+ s.VersionId = &v+ return s+}++type GetObjectLegalHoldOutput struct {+ _ struct{} `type:"structure" payload:"LegalHold"`++ // The current Legal Hold status for the specified object.+ LegalHold *ObjectLockLegalHold `type:"structure"`+}++// String returns the string representation+func (s GetObjectLegalHoldOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectLegalHoldOutput) GoString() string {+ return s.String()+}++// SetLegalHold sets the LegalHold field's value.+func (s *GetObjectLegalHoldOutput) SetLegalHold(v *ObjectLockLegalHold) *GetObjectLegalHoldOutput {+ s.LegalHold = v+ return s+}++type GetObjectLockConfigurationInput struct {+ _ struct{} `type:"structure"`++ // The bucket whose Object Lock configuration you want to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetObjectLockConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectLockConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectLockConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectLockConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectLockConfigurationInput) SetBucket(v string) *GetObjectLockConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectLockConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetObjectLockConfigurationOutput struct {+ _ struct{} `type:"structure" payload:"ObjectLockConfiguration"`++ // The specified bucket's Object Lock configuration.+ ObjectLockConfiguration *ObjectLockConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetObjectLockConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectLockConfigurationOutput) GoString() string {+ return s.String()+}++// SetObjectLockConfiguration sets the ObjectLockConfiguration field's value.+func (s *GetObjectLockConfigurationOutput) SetObjectLockConfiguration(v *ObjectLockConfiguration) *GetObjectLockConfigurationOutput {+ s.ObjectLockConfiguration = v+ return s+}++type GetObjectOutput struct {+ _ struct{} `type:"structure" payload:"Body"`++ AcceptRanges *string `location:"header" locationName:"accept-ranges" type:"string"`++ // Object data.+ Body io.ReadCloser `type:"blob"`++ // 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"`++ // Size of the body in bytes.+ ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`++ // The portion of the object returned in the response.+ ContentRange *string `location:"header" locationName:"Content-Range" type:"string"`++ // A standard MIME type describing the format of the object data.+ ContentType *string `location:"header" locationName:"Content-Type" type:"string"`++ // Specifies whether the object retrieved was (true) or was not (false) a Delete+ // Marker. If false, this response header does not appear in the response.+ DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`++ // An ETag is an opaque identifier assigned by a web server to a specific version+ // of a resource found at a URL+ ETag *string `location:"header" locationName:"ETag" type:"string"`++ // If the object expiration is configured (see PUT Bucket lifecycle), the response+ // includes this header. It includes the expiry-date and rule-id key value pairs+ // providing object expiration information. The value of the rule-id is URL+ // encoded.+ Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`++ // The date and time at which the object is no longer cacheable.+ Expires *string `location:"header" locationName:"Expires" type:"string"`++ // Last modified date of the object+ LastModified *time.Time `location:"header" locationName:"Last-Modified" type:"timestamp"`++ // A map of metadata to store with the object in S3.+ Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`++ // This is set to the number of metadata entries not returned in x-amz-meta+ // headers. This can happen if you create metadata using an API like SOAP that+ // supports more flexible metadata than the REST API. For example, using SOAP,+ // you can create metadata whose values are not legal HTTP headers.+ MissingMeta *int64 `location:"header" locationName:"x-amz-missing-meta" type:"integer"`++ // Indicates whether this object has an active legal hold. This field is only+ // returned if you have permission to view an object's legal hold status.+ ObjectLockLegalHoldStatus *string `location:"header" locationName:"x-amz-object-lock-legal-hold" type:"string" enum:"ObjectLockLegalHoldStatus"`++ // The Object Lock mode currently in place for this object.+ ObjectLockMode *string `location:"header" locationName:"x-amz-object-lock-mode" type:"string" enum:"ObjectLockMode"`++ // The date and time when this object's Object Lock will expire.+ ObjectLockRetainUntilDate *time.Time `location:"header" locationName:"x-amz-object-lock-retain-until-date" type:"timestamp" timestampFormat:"iso8601"`++ // The count of parts this object has.+ PartsCount *int64 `location:"header" locationName:"x-amz-mp-parts-count" type:"integer"`++ ReplicationStatus *string `location:"header" locationName:"x-amz-replication-status" type:"string" enum:"ReplicationStatus"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // Provides information about object restoration operation and expiration time+ // of the restored object copy.+ Restore *string `location:"header" locationName:"x-amz-restore" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`++ // The number of tags, if any, on the object.+ TagCount *int64 `location:"header" locationName:"x-amz-tagging-count" type:"integer"`++ // Version of the object.+ VersionId *string `location:"header" locationName:"x-amz-version-id" 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"`+}++// String returns the string representation+func (s GetObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectOutput) GoString() string {+ return s.String()+}++// SetAcceptRanges sets the AcceptRanges field's value.+func (s *GetObjectOutput) SetAcceptRanges(v string) *GetObjectOutput {+ s.AcceptRanges = &v+ return s+}++// SetBody sets the Body field's value.+func (s *GetObjectOutput) SetBody(v io.ReadCloser) *GetObjectOutput {+ s.Body = v+ return s+}++// SetCacheControl sets the CacheControl field's value.+func (s *GetObjectOutput) SetCacheControl(v string) *GetObjectOutput {+ s.CacheControl = &v+ return s+}++// SetContentDisposition sets the ContentDisposition field's value.+func (s *GetObjectOutput) SetContentDisposition(v string) *GetObjectOutput {+ s.ContentDisposition = &v+ return s+}++// SetContentEncoding sets the ContentEncoding field's value.+func (s *GetObjectOutput) SetContentEncoding(v string) *GetObjectOutput {+ s.ContentEncoding = &v+ return s+}++// SetContentLanguage sets the ContentLanguage field's value.+func (s *GetObjectOutput) SetContentLanguage(v string) *GetObjectOutput {+ s.ContentLanguage = &v+ return s+}++// SetContentLength sets the ContentLength field's value.+func (s *GetObjectOutput) SetContentLength(v int64) *GetObjectOutput {+ s.ContentLength = &v+ return s+}++// SetContentRange sets the ContentRange field's value.+func (s *GetObjectOutput) SetContentRange(v string) *GetObjectOutput {+ s.ContentRange = &v+ return s+}++// SetContentType sets the ContentType field's value.+func (s *GetObjectOutput) SetContentType(v string) *GetObjectOutput {+ s.ContentType = &v+ return s+}++// SetDeleteMarker sets the DeleteMarker field's value.+func (s *GetObjectOutput) SetDeleteMarker(v bool) *GetObjectOutput {+ s.DeleteMarker = &v+ return s+}++// SetETag sets the ETag field's value.+func (s *GetObjectOutput) SetETag(v string) *GetObjectOutput {+ s.ETag = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *GetObjectOutput) SetExpiration(v string) *GetObjectOutput {+ s.Expiration = &v+ return s+}++// SetExpires sets the Expires field's value.+func (s *GetObjectOutput) SetExpires(v string) *GetObjectOutput {+ s.Expires = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *GetObjectOutput) SetLastModified(v time.Time) *GetObjectOutput {+ s.LastModified = &v+ return s+}++// SetMetadata sets the Metadata field's value.+func (s *GetObjectOutput) SetMetadata(v map[string]*string) *GetObjectOutput {+ s.Metadata = v+ return s+}++// SetMissingMeta sets the MissingMeta field's value.+func (s *GetObjectOutput) SetMissingMeta(v int64) *GetObjectOutput {+ s.MissingMeta = &v+ return s+}++// SetObjectLockLegalHoldStatus sets the ObjectLockLegalHoldStatus field's value.+func (s *GetObjectOutput) SetObjectLockLegalHoldStatus(v string) *GetObjectOutput {+ s.ObjectLockLegalHoldStatus = &v+ return s+}++// SetObjectLockMode sets the ObjectLockMode field's value.+func (s *GetObjectOutput) SetObjectLockMode(v string) *GetObjectOutput {+ s.ObjectLockMode = &v+ return s+}++// SetObjectLockRetainUntilDate sets the ObjectLockRetainUntilDate field's value.+func (s *GetObjectOutput) SetObjectLockRetainUntilDate(v time.Time) *GetObjectOutput {+ s.ObjectLockRetainUntilDate = &v+ return s+}++// SetPartsCount sets the PartsCount field's value.+func (s *GetObjectOutput) SetPartsCount(v int64) *GetObjectOutput {+ s.PartsCount = &v+ return s+}++// SetReplicationStatus sets the ReplicationStatus field's value.+func (s *GetObjectOutput) SetReplicationStatus(v string) *GetObjectOutput {+ s.ReplicationStatus = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *GetObjectOutput) SetRequestCharged(v string) *GetObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetRestore sets the Restore field's value.+func (s *GetObjectOutput) SetRestore(v string) *GetObjectOutput {+ s.Restore = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *GetObjectOutput) SetSSECustomerAlgorithm(v string) *GetObjectOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *GetObjectOutput) SetSSECustomerKeyMD5(v string) *GetObjectOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *GetObjectOutput) SetSSEKMSKeyId(v string) *GetObjectOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *GetObjectOutput) SetServerSideEncryption(v string) *GetObjectOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *GetObjectOutput) SetStorageClass(v string) *GetObjectOutput {+ s.StorageClass = &v+ return s+}++// SetTagCount sets the TagCount field's value.+func (s *GetObjectOutput) SetTagCount(v int64) *GetObjectOutput {+ s.TagCount = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectOutput) SetVersionId(v string) *GetObjectOutput {+ s.VersionId = &v+ return s+}++// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.+func (s *GetObjectOutput) SetWebsiteRedirectLocation(v string) *GetObjectOutput {+ s.WebsiteRedirectLocation = &v+ return s+}++type GetObjectRetentionInput struct {+ _ struct{} `type:"structure"`++ // The bucket containing the object whose retention settings you want to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The key name for the object whose retention settings you want to retrieve.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // The version ID for the object whose retention settings you want to retrieve.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s GetObjectRetentionInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectRetentionInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectRetentionInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectRetentionInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectRetentionInput) SetBucket(v string) *GetObjectRetentionInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectRetentionInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *GetObjectRetentionInput) SetKey(v string) *GetObjectRetentionInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *GetObjectRetentionInput) SetRequestPayer(v string) *GetObjectRetentionInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectRetentionInput) SetVersionId(v string) *GetObjectRetentionInput {+ s.VersionId = &v+ return s+}++type GetObjectRetentionOutput struct {+ _ struct{} `type:"structure" payload:"Retention"`++ // The container element for an object's retention settings.+ Retention *ObjectLockRetention `type:"structure"`+}++// String returns the string representation+func (s GetObjectRetentionOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectRetentionOutput) GoString() string {+ return s.String()+}++// SetRetention sets the Retention field's value.+func (s *GetObjectRetentionOutput) SetRetention(v *ObjectLockRetention) *GetObjectRetentionOutput {+ s.Retention = v+ return s+}++type GetObjectTaggingInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s GetObjectTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectTaggingInput) SetBucket(v string) *GetObjectTaggingInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *GetObjectTaggingInput) SetKey(v string) *GetObjectTaggingInput {+ s.Key = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectTaggingInput) SetVersionId(v string) *GetObjectTaggingInput {+ s.VersionId = &v+ return s+}++type GetObjectTaggingOutput struct {+ _ struct{} `type:"structure"`++ // TagSet is a required field+ TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`++ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s GetObjectTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectTaggingOutput) GoString() string {+ return s.String()+}++// SetTagSet sets the TagSet field's value.+func (s *GetObjectTaggingOutput) SetTagSet(v []*Tag) *GetObjectTaggingOutput {+ s.TagSet = v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *GetObjectTaggingOutput) SetVersionId(v string) *GetObjectTaggingOutput {+ s.VersionId = &v+ return s+}++type GetObjectTorrentInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`+}++// String returns the string representation+func (s GetObjectTorrentInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectTorrentInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetObjectTorrentInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetObjectTorrentInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetObjectTorrentInput) SetBucket(v string) *GetObjectTorrentInput {+ s.Bucket = &v+ return s+}++func (s *GetObjectTorrentInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *GetObjectTorrentInput) SetKey(v string) *GetObjectTorrentInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *GetObjectTorrentInput) SetRequestPayer(v string) *GetObjectTorrentInput {+ s.RequestPayer = &v+ return s+}++type GetObjectTorrentOutput struct {+ _ struct{} `type:"structure" payload:"Body"`++ Body io.ReadCloser `type:"blob"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s GetObjectTorrentOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetObjectTorrentOutput) GoString() string {+ return s.String()+}++// SetBody sets the Body field's value.+func (s *GetObjectTorrentOutput) SetBody(v io.ReadCloser) *GetObjectTorrentOutput {+ s.Body = v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *GetObjectTorrentOutput) SetRequestCharged(v string) *GetObjectTorrentOutput {+ s.RequestCharged = &v+ return s+}++type GetPublicAccessBlockInput struct {+ _ struct{} `type:"structure"`++ // The name of the Amazon S3 bucket whose PublicAccessBlock configuration you+ // want to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s GetPublicAccessBlockInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetPublicAccessBlockInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetPublicAccessBlockInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetPublicAccessBlockInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *GetPublicAccessBlockInput) SetBucket(v string) *GetPublicAccessBlockInput {+ s.Bucket = &v+ return s+}++func (s *GetPublicAccessBlockInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type GetPublicAccessBlockOutput struct {+ _ struct{} `type:"structure" payload:"PublicAccessBlockConfiguration"`++ // The PublicAccessBlock configuration currently in effect for this Amazon S3+ // bucket.+ PublicAccessBlockConfiguration *PublicAccessBlockConfiguration `type:"structure"`+}++// String returns the string representation+func (s GetPublicAccessBlockOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetPublicAccessBlockOutput) GoString() string {+ return s.String()+}++// SetPublicAccessBlockConfiguration sets the PublicAccessBlockConfiguration field's value.+func (s *GetPublicAccessBlockOutput) SetPublicAccessBlockConfiguration(v *PublicAccessBlockConfiguration) *GetPublicAccessBlockOutput {+ s.PublicAccessBlockConfiguration = v+ return s+}++type GlacierJobParameters struct {+ _ struct{} `type:"structure"`++ // Glacier retrieval tier at which the restore will be processed.+ //+ // Tier is a required field+ Tier *string `type:"string" required:"true" enum:"Tier"`+}++// String returns the string representation+func (s GlacierJobParameters) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GlacierJobParameters) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GlacierJobParameters) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GlacierJobParameters"}+ if s.Tier == nil {+ invalidParams.Add(request.NewErrParamRequired("Tier"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetTier sets the Tier field's value.+func (s *GlacierJobParameters) SetTier(v string) *GlacierJobParameters {+ s.Tier = &v+ return s+}++type Grant struct {+ _ struct{} `type:"structure"`++ Grantee *Grantee `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`++ // Specifies the permission given to the grantee.+ Permission *string `type:"string" enum:"Permission"`+}++// String returns the string representation+func (s Grant) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Grant) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Grant) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Grant"}+ if s.Grantee != nil {+ if err := s.Grantee.Validate(); err != nil {+ invalidParams.AddNested("Grantee", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetGrantee sets the Grantee field's value.+func (s *Grant) SetGrantee(v *Grantee) *Grant {+ s.Grantee = v+ return s+}++// SetPermission sets the Permission field's value.+func (s *Grant) SetPermission(v string) *Grant {+ s.Permission = &v+ return s+}++type Grantee struct {+ _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`++ // Screen name of the grantee.+ DisplayName *string `type:"string"`++ // Email address of the grantee.+ EmailAddress *string `type:"string"`++ // The canonical user ID of the grantee.+ ID *string `type:"string"`++ // Type of grantee+ //+ // Type is a required field+ Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true" required:"true" enum:"Type"`++ // URI of the grantee group.+ URI *string `type:"string"`+}++// String returns the string representation+func (s Grantee) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Grantee) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Grantee) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Grantee"}+ if s.Type == nil {+ invalidParams.Add(request.NewErrParamRequired("Type"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDisplayName sets the DisplayName field's value.+func (s *Grantee) SetDisplayName(v string) *Grantee {+ s.DisplayName = &v+ return s+}++// SetEmailAddress sets the EmailAddress field's value.+func (s *Grantee) SetEmailAddress(v string) *Grantee {+ s.EmailAddress = &v+ return s+}++// SetID sets the ID field's value.+func (s *Grantee) SetID(v string) *Grantee {+ s.ID = &v+ return s+}++// SetType sets the Type field's value.+func (s *Grantee) SetType(v string) *Grantee {+ s.Type = &v+ return s+}++// SetURI sets the URI field's value.+func (s *Grantee) SetURI(v string) *Grantee {+ s.URI = &v+ return s+}++type HeadBucketInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s HeadBucketInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s HeadBucketInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *HeadBucketInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "HeadBucketInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *HeadBucketInput) SetBucket(v string) *HeadBucketInput {+ s.Bucket = &v+ return s+}++func (s *HeadBucketInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type HeadBucketOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s HeadBucketOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s HeadBucketOutput) GoString() string {+ return s.String()+}++type HeadObjectInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Return the object only if its entity tag (ETag) is the same as the one specified,+ // otherwise return a 412 (precondition failed).+ IfMatch *string `location:"header" locationName:"If-Match" type:"string"`++ // Return the object only if it has been modified since the specified time,+ // otherwise return a 304 (not modified).+ IfModifiedSince *time.Time `location:"header" locationName:"If-Modified-Since" type:"timestamp"`++ // Return the object only if its entity tag (ETag) is different from the one+ // specified, otherwise return a 304 (not modified).+ IfNoneMatch *string `location:"header" locationName:"If-None-Match" type:"string"`++ // Return the object only if it has not been modified since the specified time,+ // otherwise return a 412 (precondition failed).+ IfUnmodifiedSince *time.Time `location:"header" locationName:"If-Unmodified-Since" type:"timestamp"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Part number of the object being read. This is a positive integer between+ // 1 and 10,000. Effectively performs a 'ranged' HEAD request for the part specified.+ // Useful querying about the size of the part and the number of parts in this+ // object.+ PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer"`++ // Downloads the specified range bytes of an object. For more information about+ // the HTTP Range header, go to http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.+ Range *string `location:"header" locationName:"Range" type:"string"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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" sensitive:"true"`++ // 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"`++ // VersionId used to reference a specific version of the object.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s HeadObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s HeadObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *HeadObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "HeadObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *HeadObjectInput) SetBucket(v string) *HeadObjectInput {+ s.Bucket = &v+ return s+}++func (s *HeadObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetIfMatch sets the IfMatch field's value.+func (s *HeadObjectInput) SetIfMatch(v string) *HeadObjectInput {+ s.IfMatch = &v+ return s+}++// SetIfModifiedSince sets the IfModifiedSince field's value.+func (s *HeadObjectInput) SetIfModifiedSince(v time.Time) *HeadObjectInput {+ s.IfModifiedSince = &v+ return s+}++// SetIfNoneMatch sets the IfNoneMatch field's value.+func (s *HeadObjectInput) SetIfNoneMatch(v string) *HeadObjectInput {+ s.IfNoneMatch = &v+ return s+}++// SetIfUnmodifiedSince sets the IfUnmodifiedSince field's value.+func (s *HeadObjectInput) SetIfUnmodifiedSince(v time.Time) *HeadObjectInput {+ s.IfUnmodifiedSince = &v+ return s+}++// SetKey sets the Key field's value.+func (s *HeadObjectInput) SetKey(v string) *HeadObjectInput {+ s.Key = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *HeadObjectInput) SetPartNumber(v int64) *HeadObjectInput {+ s.PartNumber = &v+ return s+}++// SetRange sets the Range field's value.+func (s *HeadObjectInput) SetRange(v string) *HeadObjectInput {+ s.Range = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *HeadObjectInput) SetRequestPayer(v string) *HeadObjectInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *HeadObjectInput) SetSSECustomerAlgorithm(v string) *HeadObjectInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *HeadObjectInput) SetSSECustomerKey(v string) *HeadObjectInput {+ s.SSECustomerKey = &v+ return s+}++func (s *HeadObjectInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *HeadObjectInput) SetSSECustomerKeyMD5(v string) *HeadObjectInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *HeadObjectInput) SetVersionId(v string) *HeadObjectInput {+ s.VersionId = &v+ return s+}++type HeadObjectOutput struct {+ _ struct{} `type:"structure"`++ AcceptRanges *string `location:"header" locationName:"accept-ranges" type:"string"`++ // 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"`++ // Size of the body in bytes.+ ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`++ // A standard MIME type describing the format of the object data.+ ContentType *string `location:"header" locationName:"Content-Type" type:"string"`++ // Specifies whether the object retrieved was (true) or was not (false) a Delete+ // Marker. If false, this response header does not appear in the response.+ DeleteMarker *bool `location:"header" locationName:"x-amz-delete-marker" type:"boolean"`++ // An ETag is an opaque identifier assigned by a web server to a specific version+ // of a resource found at a URL+ ETag *string `location:"header" locationName:"ETag" type:"string"`++ // If the object expiration is configured (see PUT Bucket lifecycle), the response+ // includes this header. It includes the expiry-date and rule-id key value pairs+ // providing object expiration information. The value of the rule-id is URL+ // encoded.+ Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`++ // The date and time at which the object is no longer cacheable.+ Expires *string `location:"header" locationName:"Expires" type:"string"`++ // Last modified date of the object+ LastModified *time.Time `location:"header" locationName:"Last-Modified" type:"timestamp"`++ // A map of metadata to store with the object in S3.+ Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`++ // This is set to the number of metadata entries not returned in x-amz-meta+ // headers. This can happen if you create metadata using an API like SOAP that+ // supports more flexible metadata than the REST API. For example, using SOAP,+ // you can create metadata whose values are not legal HTTP headers.+ MissingMeta *int64 `location:"header" locationName:"x-amz-missing-meta" type:"integer"`++ // The Legal Hold status for the specified object.+ ObjectLockLegalHoldStatus *string `location:"header" locationName:"x-amz-object-lock-legal-hold" type:"string" enum:"ObjectLockLegalHoldStatus"`++ // The Object Lock mode currently in place for this object.+ ObjectLockMode *string `location:"header" locationName:"x-amz-object-lock-mode" type:"string" enum:"ObjectLockMode"`++ // The date and time when this object's Object Lock will expire.+ ObjectLockRetainUntilDate *time.Time `location:"header" locationName:"x-amz-object-lock-retain-until-date" type:"timestamp" timestampFormat:"iso8601"`++ // The count of parts this object has.+ PartsCount *int64 `location:"header" locationName:"x-amz-mp-parts-count" type:"integer"`++ ReplicationStatus *string `location:"header" locationName:"x-amz-replication-status" type:"string" enum:"ReplicationStatus"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // Provides information about object restoration operation and expiration time+ // of the restored object copy.+ Restore *string `location:"header" locationName:"x-amz-restore" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`++ // Version of the object.+ VersionId *string `location:"header" locationName:"x-amz-version-id" 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"`+}++// String returns the string representation+func (s HeadObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s HeadObjectOutput) GoString() string {+ return s.String()+}++// SetAcceptRanges sets the AcceptRanges field's value.+func (s *HeadObjectOutput) SetAcceptRanges(v string) *HeadObjectOutput {+ s.AcceptRanges = &v+ return s+}++// SetCacheControl sets the CacheControl field's value.+func (s *HeadObjectOutput) SetCacheControl(v string) *HeadObjectOutput {+ s.CacheControl = &v+ return s+}++// SetContentDisposition sets the ContentDisposition field's value.+func (s *HeadObjectOutput) SetContentDisposition(v string) *HeadObjectOutput {+ s.ContentDisposition = &v+ return s+}++// SetContentEncoding sets the ContentEncoding field's value.+func (s *HeadObjectOutput) SetContentEncoding(v string) *HeadObjectOutput {+ s.ContentEncoding = &v+ return s+}++// SetContentLanguage sets the ContentLanguage field's value.+func (s *HeadObjectOutput) SetContentLanguage(v string) *HeadObjectOutput {+ s.ContentLanguage = &v+ return s+}++// SetContentLength sets the ContentLength field's value.+func (s *HeadObjectOutput) SetContentLength(v int64) *HeadObjectOutput {+ s.ContentLength = &v+ return s+}++// SetContentType sets the ContentType field's value.+func (s *HeadObjectOutput) SetContentType(v string) *HeadObjectOutput {+ s.ContentType = &v+ return s+}++// SetDeleteMarker sets the DeleteMarker field's value.+func (s *HeadObjectOutput) SetDeleteMarker(v bool) *HeadObjectOutput {+ s.DeleteMarker = &v+ return s+}++// SetETag sets the ETag field's value.+func (s *HeadObjectOutput) SetETag(v string) *HeadObjectOutput {+ s.ETag = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *HeadObjectOutput) SetExpiration(v string) *HeadObjectOutput {+ s.Expiration = &v+ return s+}++// SetExpires sets the Expires field's value.+func (s *HeadObjectOutput) SetExpires(v string) *HeadObjectOutput {+ s.Expires = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *HeadObjectOutput) SetLastModified(v time.Time) *HeadObjectOutput {+ s.LastModified = &v+ return s+}++// SetMetadata sets the Metadata field's value.+func (s *HeadObjectOutput) SetMetadata(v map[string]*string) *HeadObjectOutput {+ s.Metadata = v+ return s+}++// SetMissingMeta sets the MissingMeta field's value.+func (s *HeadObjectOutput) SetMissingMeta(v int64) *HeadObjectOutput {+ s.MissingMeta = &v+ return s+}++// SetObjectLockLegalHoldStatus sets the ObjectLockLegalHoldStatus field's value.+func (s *HeadObjectOutput) SetObjectLockLegalHoldStatus(v string) *HeadObjectOutput {+ s.ObjectLockLegalHoldStatus = &v+ return s+}++// SetObjectLockMode sets the ObjectLockMode field's value.+func (s *HeadObjectOutput) SetObjectLockMode(v string) *HeadObjectOutput {+ s.ObjectLockMode = &v+ return s+}++// SetObjectLockRetainUntilDate sets the ObjectLockRetainUntilDate field's value.+func (s *HeadObjectOutput) SetObjectLockRetainUntilDate(v time.Time) *HeadObjectOutput {+ s.ObjectLockRetainUntilDate = &v+ return s+}++// SetPartsCount sets the PartsCount field's value.+func (s *HeadObjectOutput) SetPartsCount(v int64) *HeadObjectOutput {+ s.PartsCount = &v+ return s+}++// SetReplicationStatus sets the ReplicationStatus field's value.+func (s *HeadObjectOutput) SetReplicationStatus(v string) *HeadObjectOutput {+ s.ReplicationStatus = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *HeadObjectOutput) SetRequestCharged(v string) *HeadObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetRestore sets the Restore field's value.+func (s *HeadObjectOutput) SetRestore(v string) *HeadObjectOutput {+ s.Restore = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *HeadObjectOutput) SetSSECustomerAlgorithm(v string) *HeadObjectOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *HeadObjectOutput) SetSSECustomerKeyMD5(v string) *HeadObjectOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *HeadObjectOutput) SetSSEKMSKeyId(v string) *HeadObjectOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *HeadObjectOutput) SetServerSideEncryption(v string) *HeadObjectOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *HeadObjectOutput) SetStorageClass(v string) *HeadObjectOutput {+ s.StorageClass = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *HeadObjectOutput) SetVersionId(v string) *HeadObjectOutput {+ s.VersionId = &v+ return s+}++// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.+func (s *HeadObjectOutput) SetWebsiteRedirectLocation(v string) *HeadObjectOutput {+ s.WebsiteRedirectLocation = &v+ return s+}++type IndexDocument struct {+ _ struct{} `type:"structure"`++ // A suffix that is appended to a request that is for a directory on the website+ // endpoint (e.g. if the suffix is index.html and you make a request to samplebucket/images/+ // the data that is returned will be for the object with the key name images/index.html)+ // The suffix must not be empty and must not include a slash character.+ //+ // Suffix is a required field+ Suffix *string `type:"string" required:"true"`+}++// String returns the string representation+func (s IndexDocument) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s IndexDocument) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *IndexDocument) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "IndexDocument"}+ if s.Suffix == nil {+ invalidParams.Add(request.NewErrParamRequired("Suffix"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetSuffix sets the Suffix field's value.+func (s *IndexDocument) SetSuffix(v string) *IndexDocument {+ s.Suffix = &v+ return s+}++type Initiator struct {+ _ struct{} `type:"structure"`++ // Name of the Principal.+ DisplayName *string `type:"string"`++ // If the principal is an AWS account, it provides the Canonical User ID. If+ // the principal is an IAM User, it provides a user ARN value.+ ID *string `type:"string"`+}++// String returns the string representation+func (s Initiator) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Initiator) GoString() string {+ return s.String()+}++// SetDisplayName sets the DisplayName field's value.+func (s *Initiator) SetDisplayName(v string) *Initiator {+ s.DisplayName = &v+ return s+}++// SetID sets the ID field's value.+func (s *Initiator) SetID(v string) *Initiator {+ s.ID = &v+ return s+}++// Describes the serialization format of the object.+type InputSerialization struct {+ _ struct{} `type:"structure"`++ // Describes the serialization of a CSV-encoded object.+ CSV *CSVInput `type:"structure"`++ // Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default+ // Value: NONE.+ CompressionType *string `type:"string" enum:"CompressionType"`++ // Specifies JSON as object's input serialization format.+ JSON *JSONInput `type:"structure"`++ // Specifies Parquet as object's input serialization format.+ Parquet *ParquetInput `type:"structure"`+}++// String returns the string representation+func (s InputSerialization) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InputSerialization) GoString() string {+ return s.String()+}++// SetCSV sets the CSV field's value.+func (s *InputSerialization) SetCSV(v *CSVInput) *InputSerialization {+ s.CSV = v+ return s+}++// SetCompressionType sets the CompressionType field's value.+func (s *InputSerialization) SetCompressionType(v string) *InputSerialization {+ s.CompressionType = &v+ return s+}++// SetJSON sets the JSON field's value.+func (s *InputSerialization) SetJSON(v *JSONInput) *InputSerialization {+ s.JSON = v+ return s+}++// SetParquet sets the Parquet field's value.+func (s *InputSerialization) SetParquet(v *ParquetInput) *InputSerialization {+ s.Parquet = v+ return s+}++type InventoryConfiguration struct {+ _ struct{} `type:"structure"`++ // Contains information about where to publish the inventory results.+ //+ // Destination is a required field+ Destination *InventoryDestination `type:"structure" required:"true"`++ // Specifies an inventory filter. The inventory only includes objects that meet+ // the filter's criteria.+ Filter *InventoryFilter `type:"structure"`++ // The ID used to identify the inventory configuration.+ //+ // Id is a required field+ Id *string `type:"string" required:"true"`++ // Specifies which object version(s) to included in the inventory results.+ //+ // IncludedObjectVersions is a required field+ IncludedObjectVersions *string `type:"string" required:"true" enum:"InventoryIncludedObjectVersions"`++ // Specifies whether the inventory is enabled or disabled.+ //+ // IsEnabled is a required field+ IsEnabled *bool `type:"boolean" required:"true"`++ // Contains the optional fields that are included in the inventory results.+ OptionalFields []*string `locationNameList:"Field" type:"list"`++ // Specifies the schedule for generating inventory results.+ //+ // Schedule is a required field+ Schedule *InventorySchedule `type:"structure" required:"true"`+}++// String returns the string representation+func (s InventoryConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventoryConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventoryConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventoryConfiguration"}+ if s.Destination == nil {+ invalidParams.Add(request.NewErrParamRequired("Destination"))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.IncludedObjectVersions == nil {+ invalidParams.Add(request.NewErrParamRequired("IncludedObjectVersions"))+ }+ if s.IsEnabled == nil {+ invalidParams.Add(request.NewErrParamRequired("IsEnabled"))+ }+ if s.Schedule == nil {+ invalidParams.Add(request.NewErrParamRequired("Schedule"))+ }+ if s.Destination != nil {+ if err := s.Destination.Validate(); err != nil {+ invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))+ }+ }+ if s.Filter != nil {+ if err := s.Filter.Validate(); err != nil {+ invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))+ }+ }+ if s.Schedule != nil {+ if err := s.Schedule.Validate(); err != nil {+ invalidParams.AddNested("Schedule", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDestination sets the Destination field's value.+func (s *InventoryConfiguration) SetDestination(v *InventoryDestination) *InventoryConfiguration {+ s.Destination = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *InventoryConfiguration) SetFilter(v *InventoryFilter) *InventoryConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *InventoryConfiguration) SetId(v string) *InventoryConfiguration {+ s.Id = &v+ return s+}++// SetIncludedObjectVersions sets the IncludedObjectVersions field's value.+func (s *InventoryConfiguration) SetIncludedObjectVersions(v string) *InventoryConfiguration {+ s.IncludedObjectVersions = &v+ return s+}++// SetIsEnabled sets the IsEnabled field's value.+func (s *InventoryConfiguration) SetIsEnabled(v bool) *InventoryConfiguration {+ s.IsEnabled = &v+ return s+}++// SetOptionalFields sets the OptionalFields field's value.+func (s *InventoryConfiguration) SetOptionalFields(v []*string) *InventoryConfiguration {+ s.OptionalFields = v+ return s+}++// SetSchedule sets the Schedule field's value.+func (s *InventoryConfiguration) SetSchedule(v *InventorySchedule) *InventoryConfiguration {+ s.Schedule = v+ return s+}++type InventoryDestination struct {+ _ struct{} `type:"structure"`++ // Contains the bucket name, file format, bucket owner (optional), and prefix+ // (optional) where inventory results are published.+ //+ // S3BucketDestination is a required field+ S3BucketDestination *InventoryS3BucketDestination `type:"structure" required:"true"`+}++// String returns the string representation+func (s InventoryDestination) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventoryDestination) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventoryDestination) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventoryDestination"}+ if s.S3BucketDestination == nil {+ invalidParams.Add(request.NewErrParamRequired("S3BucketDestination"))+ }+ if s.S3BucketDestination != nil {+ if err := s.S3BucketDestination.Validate(); err != nil {+ invalidParams.AddNested("S3BucketDestination", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetS3BucketDestination sets the S3BucketDestination field's value.+func (s *InventoryDestination) SetS3BucketDestination(v *InventoryS3BucketDestination) *InventoryDestination {+ s.S3BucketDestination = v+ return s+}++// Contains the type of server-side encryption used to encrypt the inventory+// results.+type InventoryEncryption struct {+ _ struct{} `type:"structure"`++ // Specifies the use of SSE-KMS to encrypt delivered Inventory reports.+ SSEKMS *SSEKMS `locationName:"SSE-KMS" type:"structure"`++ // Specifies the use of SSE-S3 to encrypt delivered Inventory reports.+ SSES3 *SSES3 `locationName:"SSE-S3" type:"structure"`+}++// String returns the string representation+func (s InventoryEncryption) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventoryEncryption) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventoryEncryption) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventoryEncryption"}+ if s.SSEKMS != nil {+ if err := s.SSEKMS.Validate(); err != nil {+ invalidParams.AddNested("SSEKMS", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetSSEKMS sets the SSEKMS field's value.+func (s *InventoryEncryption) SetSSEKMS(v *SSEKMS) *InventoryEncryption {+ s.SSEKMS = v+ return s+}++// SetSSES3 sets the SSES3 field's value.+func (s *InventoryEncryption) SetSSES3(v *SSES3) *InventoryEncryption {+ s.SSES3 = v+ return s+}++type InventoryFilter struct {+ _ struct{} `type:"structure"`++ // The prefix that an object must have to be included in the inventory results.+ //+ // Prefix is a required field+ Prefix *string `type:"string" required:"true"`+}++// String returns the string representation+func (s InventoryFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventoryFilter) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventoryFilter) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventoryFilter"}+ if s.Prefix == nil {+ invalidParams.Add(request.NewErrParamRequired("Prefix"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPrefix sets the Prefix field's value.+func (s *InventoryFilter) SetPrefix(v string) *InventoryFilter {+ s.Prefix = &v+ return s+}++type InventoryS3BucketDestination struct {+ _ struct{} `type:"structure"`++ // The ID of the account that owns the destination bucket.+ AccountId *string `type:"string"`++ // The Amazon resource name (ARN) of the bucket where inventory results will+ // be published.+ //+ // Bucket is a required field+ Bucket *string `type:"string" required:"true"`++ // Contains the type of server-side encryption used to encrypt the inventory+ // results.+ Encryption *InventoryEncryption `type:"structure"`++ // Specifies the output format of the inventory results.+ //+ // Format is a required field+ Format *string `type:"string" required:"true" enum:"InventoryFormat"`++ // The prefix that is prepended to all inventory results.+ Prefix *string `type:"string"`+}++// String returns the string representation+func (s InventoryS3BucketDestination) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventoryS3BucketDestination) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventoryS3BucketDestination) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventoryS3BucketDestination"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Format == nil {+ invalidParams.Add(request.NewErrParamRequired("Format"))+ }+ if s.Encryption != nil {+ if err := s.Encryption.Validate(); err != nil {+ invalidParams.AddNested("Encryption", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAccountId sets the AccountId field's value.+func (s *InventoryS3BucketDestination) SetAccountId(v string) *InventoryS3BucketDestination {+ s.AccountId = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *InventoryS3BucketDestination) SetBucket(v string) *InventoryS3BucketDestination {+ s.Bucket = &v+ return s+}++func (s *InventoryS3BucketDestination) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetEncryption sets the Encryption field's value.+func (s *InventoryS3BucketDestination) SetEncryption(v *InventoryEncryption) *InventoryS3BucketDestination {+ s.Encryption = v+ return s+}++// SetFormat sets the Format field's value.+func (s *InventoryS3BucketDestination) SetFormat(v string) *InventoryS3BucketDestination {+ s.Format = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *InventoryS3BucketDestination) SetPrefix(v string) *InventoryS3BucketDestination {+ s.Prefix = &v+ return s+}++type InventorySchedule struct {+ _ struct{} `type:"structure"`++ // Specifies how frequently inventory results are produced.+ //+ // Frequency is a required field+ Frequency *string `type:"string" required:"true" enum:"InventoryFrequency"`+}++// String returns the string representation+func (s InventorySchedule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s InventorySchedule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *InventorySchedule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "InventorySchedule"}+ if s.Frequency == nil {+ invalidParams.Add(request.NewErrParamRequired("Frequency"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetFrequency sets the Frequency field's value.+func (s *InventorySchedule) SetFrequency(v string) *InventorySchedule {+ s.Frequency = &v+ return s+}++type JSONInput struct {+ _ struct{} `type:"structure"`++ // The type of JSON. Valid values: Document, Lines.+ Type *string `type:"string" enum:"JSONType"`+}++// String returns the string representation+func (s JSONInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s JSONInput) GoString() string {+ return s.String()+}++// SetType sets the Type field's value.+func (s *JSONInput) SetType(v string) *JSONInput {+ s.Type = &v+ return s+}++type JSONOutput struct {+ _ struct{} `type:"structure"`++ // The value used to separate individual records in the output.+ RecordDelimiter *string `type:"string"`+}++// String returns the string representation+func (s JSONOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s JSONOutput) GoString() string {+ return s.String()+}++// SetRecordDelimiter sets the RecordDelimiter field's value.+func (s *JSONOutput) SetRecordDelimiter(v string) *JSONOutput {+ s.RecordDelimiter = &v+ return s+}++// A container for object key name prefix and suffix filtering rules.+type KeyFilter struct {+ _ struct{} `type:"structure"`++ // A list of containers for the key value pair that defines the criteria for+ // the filter rule.+ FilterRules []*FilterRule `locationName:"FilterRule" type:"list" flattened:"true"`+}++// String returns the string representation+func (s KeyFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s KeyFilter) GoString() string {+ return s.String()+}++// SetFilterRules sets the FilterRules field's value.+func (s *KeyFilter) SetFilterRules(v []*FilterRule) *KeyFilter {+ s.FilterRules = v+ return s+}++// A container for specifying the configuration for AWS Lambda notifications.+type LambdaFunctionConfiguration struct {+ _ struct{} `type:"structure"`++ // Events is a required field+ Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`++ // A container for object key name filtering rules. For information about key+ // name filtering, see Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)+ // in the Amazon Simple Storage Service Developer Guide.+ Filter *NotificationConfigurationFilter `type:"structure"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ // The Amazon Resource Name (ARN) of the Lambda cloud function that Amazon S3+ // can invoke when it detects events of the specified type.+ //+ // LambdaFunctionArn is a required field+ LambdaFunctionArn *string `locationName:"CloudFunction" type:"string" required:"true"`+}++// String returns the string representation+func (s LambdaFunctionConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LambdaFunctionConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LambdaFunctionConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LambdaFunctionConfiguration"}+ if s.Events == nil {+ invalidParams.Add(request.NewErrParamRequired("Events"))+ }+ if s.LambdaFunctionArn == nil {+ invalidParams.Add(request.NewErrParamRequired("LambdaFunctionArn"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetEvents sets the Events field's value.+func (s *LambdaFunctionConfiguration) SetEvents(v []*string) *LambdaFunctionConfiguration {+ s.Events = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *LambdaFunctionConfiguration) SetFilter(v *NotificationConfigurationFilter) *LambdaFunctionConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *LambdaFunctionConfiguration) SetId(v string) *LambdaFunctionConfiguration {+ s.Id = &v+ return s+}++// SetLambdaFunctionArn sets the LambdaFunctionArn field's value.+func (s *LambdaFunctionConfiguration) SetLambdaFunctionArn(v string) *LambdaFunctionConfiguration {+ s.LambdaFunctionArn = &v+ return s+}++type LifecycleConfiguration struct {+ _ struct{} `type:"structure"`++ // Rules is a required field+ Rules []*Rule `locationName:"Rule" type:"list" flattened:"true" required:"true"`+}++// String returns the string representation+func (s LifecycleConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LifecycleConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LifecycleConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LifecycleConfiguration"}+ if s.Rules == nil {+ invalidParams.Add(request.NewErrParamRequired("Rules"))+ }+ if s.Rules != nil {+ for i, v := range s.Rules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetRules sets the Rules field's value.+func (s *LifecycleConfiguration) SetRules(v []*Rule) *LifecycleConfiguration {+ s.Rules = v+ return s+}++type LifecycleExpiration struct {+ _ struct{} `type:"structure"`++ // Indicates at what date the object is to be moved or deleted. Should be in+ // GMT ISO 8601 Format.+ Date *time.Time `type:"timestamp" timestampFormat:"iso8601"`++ // Indicates the lifetime, in days, of the objects that are subject to the rule.+ // The value must be a non-zero positive integer.+ Days *int64 `type:"integer"`++ // Indicates whether Amazon S3 will remove a delete marker with no noncurrent+ // versions. If set to true, the delete marker will be expired; if set to false+ // the policy takes no action. This cannot be specified with Days or Date in+ // a Lifecycle Expiration Policy.+ ExpiredObjectDeleteMarker *bool `type:"boolean"`+}++// String returns the string representation+func (s LifecycleExpiration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LifecycleExpiration) GoString() string {+ return s.String()+}++// SetDate sets the Date field's value.+func (s *LifecycleExpiration) SetDate(v time.Time) *LifecycleExpiration {+ s.Date = &v+ return s+}++// SetDays sets the Days field's value.+func (s *LifecycleExpiration) SetDays(v int64) *LifecycleExpiration {+ s.Days = &v+ return s+}++// SetExpiredObjectDeleteMarker sets the ExpiredObjectDeleteMarker field's value.+func (s *LifecycleExpiration) SetExpiredObjectDeleteMarker(v bool) *LifecycleExpiration {+ s.ExpiredObjectDeleteMarker = &v+ return s+}++type LifecycleRule struct {+ _ struct{} `type:"structure"`++ // Specifies the days since the initiation of an Incomplete Multipart Upload+ // that Lifecycle will wait before permanently removing all parts of the upload.+ AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload `type:"structure"`++ Expiration *LifecycleExpiration `type:"structure"`++ // The Filter is used to identify objects that a Lifecycle Rule applies to.+ // A Filter must have exactly one of Prefix, Tag, or And specified.+ Filter *LifecycleRuleFilter `type:"structure"`++ // Unique identifier for the rule. The value cannot be longer than 255 characters.+ ID *string `type:"string"`++ // Specifies when noncurrent object versions expire. Upon expiration, Amazon+ // S3 permanently deletes the noncurrent object versions. You set this lifecycle+ // configuration action on a bucket that has versioning enabled (or suspended)+ // to request that Amazon S3 delete noncurrent object versions at a specific+ // period in the object's lifetime.+ NoncurrentVersionExpiration *NoncurrentVersionExpiration `type:"structure"`++ NoncurrentVersionTransitions []*NoncurrentVersionTransition `locationName:"NoncurrentVersionTransition" type:"list" flattened:"true"`++ // Prefix identifying one or more objects to which the rule applies. This is+ // deprecated; use Filter instead.+ //+ // Deprecated: Prefix has been deprecated+ Prefix *string `deprecated:"true" type:"string"`++ // If 'Enabled', the rule is currently being applied. If 'Disabled', the rule+ // is not currently being applied.+ //+ // Status is a required field+ Status *string `type:"string" required:"true" enum:"ExpirationStatus"`++ Transitions []*Transition `locationName:"Transition" type:"list" flattened:"true"`+}++// String returns the string representation+func (s LifecycleRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LifecycleRule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LifecycleRule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LifecycleRule"}+ if s.Status == nil {+ invalidParams.Add(request.NewErrParamRequired("Status"))+ }+ if s.Filter != nil {+ if err := s.Filter.Validate(); err != nil {+ invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAbortIncompleteMultipartUpload sets the AbortIncompleteMultipartUpload field's value.+func (s *LifecycleRule) SetAbortIncompleteMultipartUpload(v *AbortIncompleteMultipartUpload) *LifecycleRule {+ s.AbortIncompleteMultipartUpload = v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *LifecycleRule) SetExpiration(v *LifecycleExpiration) *LifecycleRule {+ s.Expiration = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *LifecycleRule) SetFilter(v *LifecycleRuleFilter) *LifecycleRule {+ s.Filter = v+ return s+}++// SetID sets the ID field's value.+func (s *LifecycleRule) SetID(v string) *LifecycleRule {+ s.ID = &v+ return s+}++// SetNoncurrentVersionExpiration sets the NoncurrentVersionExpiration field's value.+func (s *LifecycleRule) SetNoncurrentVersionExpiration(v *NoncurrentVersionExpiration) *LifecycleRule {+ s.NoncurrentVersionExpiration = v+ return s+}++// SetNoncurrentVersionTransitions sets the NoncurrentVersionTransitions field's value.+func (s *LifecycleRule) SetNoncurrentVersionTransitions(v []*NoncurrentVersionTransition) *LifecycleRule {+ s.NoncurrentVersionTransitions = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *LifecycleRule) SetPrefix(v string) *LifecycleRule {+ s.Prefix = &v+ return s+}++// SetStatus sets the Status field's value.+func (s *LifecycleRule) SetStatus(v string) *LifecycleRule {+ s.Status = &v+ return s+}++// SetTransitions sets the Transitions field's value.+func (s *LifecycleRule) SetTransitions(v []*Transition) *LifecycleRule {+ s.Transitions = v+ return s+}++// This is used in a Lifecycle Rule Filter to apply a logical AND to two or+// more predicates. The Lifecycle Rule will apply to any object matching all+// of the predicates configured inside the And operator.+type LifecycleRuleAndOperator struct {+ _ struct{} `type:"structure"`++ Prefix *string `type:"string"`++ // All of these tags must exist in the object's tag set in order for the rule+ // to apply.+ Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`+}++// String returns the string representation+func (s LifecycleRuleAndOperator) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LifecycleRuleAndOperator) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LifecycleRuleAndOperator) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LifecycleRuleAndOperator"}+ if s.Tags != nil {+ for i, v := range s.Tags {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPrefix sets the Prefix field's value.+func (s *LifecycleRuleAndOperator) SetPrefix(v string) *LifecycleRuleAndOperator {+ s.Prefix = &v+ return s+}++// SetTags sets the Tags field's value.+func (s *LifecycleRuleAndOperator) SetTags(v []*Tag) *LifecycleRuleAndOperator {+ s.Tags = v+ return s+}++// The Filter is used to identify objects that a Lifecycle Rule applies to.+// A Filter must have exactly one of Prefix, Tag, or And specified.+type LifecycleRuleFilter struct {+ _ struct{} `type:"structure"`++ // This is used in a Lifecycle Rule Filter to apply a logical AND to two or+ // more predicates. The Lifecycle Rule will apply to any object matching all+ // of the predicates configured inside the And operator.+ And *LifecycleRuleAndOperator `type:"structure"`++ // Prefix identifying one or more objects to which the rule applies.+ Prefix *string `type:"string"`++ // This tag must exist in the object's tag set in order for the rule to apply.+ Tag *Tag `type:"structure"`+}++// String returns the string representation+func (s LifecycleRuleFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LifecycleRuleFilter) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LifecycleRuleFilter) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LifecycleRuleFilter"}+ if s.And != nil {+ if err := s.And.Validate(); err != nil {+ invalidParams.AddNested("And", err.(request.ErrInvalidParams))+ }+ }+ if s.Tag != nil {+ if err := s.Tag.Validate(); err != nil {+ invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAnd sets the And field's value.+func (s *LifecycleRuleFilter) SetAnd(v *LifecycleRuleAndOperator) *LifecycleRuleFilter {+ s.And = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *LifecycleRuleFilter) SetPrefix(v string) *LifecycleRuleFilter {+ s.Prefix = &v+ return s+}++// SetTag sets the Tag field's value.+func (s *LifecycleRuleFilter) SetTag(v *Tag) *LifecycleRuleFilter {+ s.Tag = v+ return s+}++type ListBucketAnalyticsConfigurationsInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket from which analytics configurations are retrieved.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ContinuationToken that represents a placeholder from where this request+ // should begin.+ ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`+}++// String returns the string representation+func (s ListBucketAnalyticsConfigurationsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketAnalyticsConfigurationsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListBucketAnalyticsConfigurationsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListBucketAnalyticsConfigurationsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListBucketAnalyticsConfigurationsInput) SetBucket(v string) *ListBucketAnalyticsConfigurationsInput {+ s.Bucket = &v+ return s+}++func (s *ListBucketAnalyticsConfigurationsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketAnalyticsConfigurationsInput) SetContinuationToken(v string) *ListBucketAnalyticsConfigurationsInput {+ s.ContinuationToken = &v+ return s+}++type ListBucketAnalyticsConfigurationsOutput struct {+ _ struct{} `type:"structure"`++ // The list of analytics configurations for a bucket.+ AnalyticsConfigurationList []*AnalyticsConfiguration `locationName:"AnalyticsConfiguration" type:"list" flattened:"true"`++ // The ContinuationToken that represents where this request began.+ ContinuationToken *string `type:"string"`++ // Indicates whether the returned list of analytics configurations is complete.+ // A value of true indicates that the list is not complete and the NextContinuationToken+ // will be provided for a subsequent request.+ IsTruncated *bool `type:"boolean"`++ // NextContinuationToken is sent when isTruncated is true, which indicates that+ // there are more analytics configurations to list. The next request must include+ // this NextContinuationToken. The token is obfuscated and is not a usable value.+ NextContinuationToken *string `type:"string"`+}++// String returns the string representation+func (s ListBucketAnalyticsConfigurationsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketAnalyticsConfigurationsOutput) GoString() string {+ return s.String()+}++// SetAnalyticsConfigurationList sets the AnalyticsConfigurationList field's value.+func (s *ListBucketAnalyticsConfigurationsOutput) SetAnalyticsConfigurationList(v []*AnalyticsConfiguration) *ListBucketAnalyticsConfigurationsOutput {+ s.AnalyticsConfigurationList = v+ return s+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketAnalyticsConfigurationsOutput) SetContinuationToken(v string) *ListBucketAnalyticsConfigurationsOutput {+ s.ContinuationToken = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListBucketAnalyticsConfigurationsOutput) SetIsTruncated(v bool) *ListBucketAnalyticsConfigurationsOutput {+ s.IsTruncated = &v+ return s+}++// SetNextContinuationToken sets the NextContinuationToken field's value.+func (s *ListBucketAnalyticsConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketAnalyticsConfigurationsOutput {+ s.NextContinuationToken = &v+ return s+}++type ListBucketInventoryConfigurationsInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the inventory configurations to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The marker used to continue an inventory configuration listing that has been+ // truncated. Use the NextContinuationToken from a previously truncated list+ // response to continue the listing. The continuation token is an opaque value+ // that Amazon S3 understands.+ ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`+}++// String returns the string representation+func (s ListBucketInventoryConfigurationsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketInventoryConfigurationsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListBucketInventoryConfigurationsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListBucketInventoryConfigurationsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListBucketInventoryConfigurationsInput) SetBucket(v string) *ListBucketInventoryConfigurationsInput {+ s.Bucket = &v+ return s+}++func (s *ListBucketInventoryConfigurationsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketInventoryConfigurationsInput) SetContinuationToken(v string) *ListBucketInventoryConfigurationsInput {+ s.ContinuationToken = &v+ return s+}++type ListBucketInventoryConfigurationsOutput struct {+ _ struct{} `type:"structure"`++ // If sent in the request, the marker that is used as a starting point for this+ // inventory configuration list response.+ ContinuationToken *string `type:"string"`++ // The list of inventory configurations for a bucket.+ InventoryConfigurationList []*InventoryConfiguration `locationName:"InventoryConfiguration" type:"list" flattened:"true"`++ // Indicates whether the returned list of inventory configurations is truncated+ // in this response. A value of true indicates that the list is truncated.+ IsTruncated *bool `type:"boolean"`++ // The marker used to continue this inventory configuration listing. Use the+ // NextContinuationToken from this response to continue the listing in a subsequent+ // request. The continuation token is an opaque value that Amazon S3 understands.+ NextContinuationToken *string `type:"string"`+}++// String returns the string representation+func (s ListBucketInventoryConfigurationsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketInventoryConfigurationsOutput) GoString() string {+ return s.String()+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketInventoryConfigurationsOutput) SetContinuationToken(v string) *ListBucketInventoryConfigurationsOutput {+ s.ContinuationToken = &v+ return s+}++// SetInventoryConfigurationList sets the InventoryConfigurationList field's value.+func (s *ListBucketInventoryConfigurationsOutput) SetInventoryConfigurationList(v []*InventoryConfiguration) *ListBucketInventoryConfigurationsOutput {+ s.InventoryConfigurationList = v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListBucketInventoryConfigurationsOutput) SetIsTruncated(v bool) *ListBucketInventoryConfigurationsOutput {+ s.IsTruncated = &v+ return s+}++// SetNextContinuationToken sets the NextContinuationToken field's value.+func (s *ListBucketInventoryConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketInventoryConfigurationsOutput {+ s.NextContinuationToken = &v+ return s+}++type ListBucketMetricsConfigurationsInput struct {+ _ struct{} `type:"structure"`++ // The name of the bucket containing the metrics configurations to retrieve.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The marker that is used to continue a metrics configuration listing that+ // has been truncated. Use the NextContinuationToken from a previously truncated+ // list response to continue the listing. The continuation token is an opaque+ // value that Amazon S3 understands.+ ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`+}++// String returns the string representation+func (s ListBucketMetricsConfigurationsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketMetricsConfigurationsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListBucketMetricsConfigurationsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListBucketMetricsConfigurationsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListBucketMetricsConfigurationsInput) SetBucket(v string) *ListBucketMetricsConfigurationsInput {+ s.Bucket = &v+ return s+}++func (s *ListBucketMetricsConfigurationsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketMetricsConfigurationsInput) SetContinuationToken(v string) *ListBucketMetricsConfigurationsInput {+ s.ContinuationToken = &v+ return s+}++type ListBucketMetricsConfigurationsOutput struct {+ _ struct{} `type:"structure"`++ // The marker that is used as a starting point for this metrics configuration+ // list response. This value is present if it was sent in the request.+ ContinuationToken *string `type:"string"`++ // Indicates whether the returned list of metrics configurations is complete.+ // A value of true indicates that the list is not complete and the NextContinuationToken+ // will be provided for a subsequent request.+ IsTruncated *bool `type:"boolean"`++ // The list of metrics configurations for a bucket.+ MetricsConfigurationList []*MetricsConfiguration `locationName:"MetricsConfiguration" type:"list" flattened:"true"`++ // The marker used to continue a metrics configuration listing that has been+ // truncated. Use the NextContinuationToken from a previously truncated list+ // response to continue the listing. The continuation token is an opaque value+ // that Amazon S3 understands.+ NextContinuationToken *string `type:"string"`+}++// String returns the string representation+func (s ListBucketMetricsConfigurationsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketMetricsConfigurationsOutput) GoString() string {+ return s.String()+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListBucketMetricsConfigurationsOutput) SetContinuationToken(v string) *ListBucketMetricsConfigurationsOutput {+ s.ContinuationToken = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListBucketMetricsConfigurationsOutput) SetIsTruncated(v bool) *ListBucketMetricsConfigurationsOutput {+ s.IsTruncated = &v+ return s+}++// SetMetricsConfigurationList sets the MetricsConfigurationList field's value.+func (s *ListBucketMetricsConfigurationsOutput) SetMetricsConfigurationList(v []*MetricsConfiguration) *ListBucketMetricsConfigurationsOutput {+ s.MetricsConfigurationList = v+ return s+}++// SetNextContinuationToken sets the NextContinuationToken field's value.+func (s *ListBucketMetricsConfigurationsOutput) SetNextContinuationToken(v string) *ListBucketMetricsConfigurationsOutput {+ s.NextContinuationToken = &v+ return s+}++type ListBucketsInput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s ListBucketsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketsInput) GoString() string {+ return s.String()+}++type ListBucketsOutput struct {+ _ struct{} `type:"structure"`++ Buckets []*Bucket `locationNameList:"Bucket" type:"list"`++ Owner *Owner `type:"structure"`+}++// String returns the string representation+func (s ListBucketsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListBucketsOutput) GoString() string {+ return s.String()+}++// SetBuckets sets the Buckets field's value.+func (s *ListBucketsOutput) SetBuckets(v []*Bucket) *ListBucketsOutput {+ s.Buckets = v+ return s+}++// SetOwner sets the Owner field's value.+func (s *ListBucketsOutput) SetOwner(v *Owner) *ListBucketsOutput {+ s.Owner = v+ return s+}++type ListMultipartUploadsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Character you use to group keys.+ Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`++ // Requests Amazon S3 to encode the object keys in the response and specifies+ // the encoding method to use. An object key may contain any Unicode character;+ // however, XML 1.0 parser cannot parse some characters, such as characters+ // with an ASCII value from 0 to 10. For characters that are not supported in+ // XML 1.0, you can add this parameter to request that Amazon S3 encode the+ // keys in the response.+ EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`++ // Together with upload-id-marker, this parameter specifies the multipart upload+ // after which listing should begin.+ KeyMarker *string `location:"querystring" locationName:"key-marker" type:"string"`++ // Sets the maximum number of multipart uploads, from 1 to 1,000, to return+ // in the response body. 1,000 is the maximum number of uploads that can be+ // returned in a response.+ MaxUploads *int64 `location:"querystring" locationName:"max-uploads" type:"integer"`++ // Lists in-progress uploads only for those keys that begin with the specified+ // prefix.+ Prefix *string `location:"querystring" locationName:"prefix" type:"string"`++ // Together with key-marker, specifies the multipart upload after which listing+ // should begin. If key-marker is not specified, the upload-id-marker parameter+ // is ignored.+ UploadIdMarker *string `location:"querystring" locationName:"upload-id-marker" type:"string"`+}++// String returns the string representation+func (s ListMultipartUploadsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListMultipartUploadsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListMultipartUploadsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListMultipartUploadsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListMultipartUploadsInput) SetBucket(v string) *ListMultipartUploadsInput {+ s.Bucket = &v+ return s+}++func (s *ListMultipartUploadsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListMultipartUploadsInput) SetDelimiter(v string) *ListMultipartUploadsInput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListMultipartUploadsInput) SetEncodingType(v string) *ListMultipartUploadsInput {+ s.EncodingType = &v+ return s+}++// SetKeyMarker sets the KeyMarker field's value.+func (s *ListMultipartUploadsInput) SetKeyMarker(v string) *ListMultipartUploadsInput {+ s.KeyMarker = &v+ return s+}++// SetMaxUploads sets the MaxUploads field's value.+func (s *ListMultipartUploadsInput) SetMaxUploads(v int64) *ListMultipartUploadsInput {+ s.MaxUploads = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListMultipartUploadsInput) SetPrefix(v string) *ListMultipartUploadsInput {+ s.Prefix = &v+ return s+}++// SetUploadIdMarker sets the UploadIdMarker field's value.+func (s *ListMultipartUploadsInput) SetUploadIdMarker(v string) *ListMultipartUploadsInput {+ s.UploadIdMarker = &v+ return s+}++type ListMultipartUploadsOutput struct {+ _ struct{} `type:"structure"`++ // Name of the bucket to which the multipart upload was initiated.+ Bucket *string `type:"string"`++ CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`++ Delimiter *string `type:"string"`++ // Encoding type used by Amazon S3 to encode object keys in the response.+ EncodingType *string `type:"string" enum:"EncodingType"`++ // Indicates whether the returned list of multipart uploads is truncated. A+ // value of true indicates that the list was truncated. The list can be truncated+ // if the number of multipart uploads exceeds the limit allowed or specified+ // by max uploads.+ IsTruncated *bool `type:"boolean"`++ // The key at or after which the listing began.+ KeyMarker *string `type:"string"`++ // Maximum number of multipart uploads that could have been included in the+ // response.+ MaxUploads *int64 `type:"integer"`++ // When a list is truncated, this element specifies the value that should be+ // used for the key-marker request parameter in a subsequent request.+ NextKeyMarker *string `type:"string"`++ // When a list is truncated, this element specifies the value that should be+ // used for the upload-id-marker request parameter in a subsequent request.+ NextUploadIdMarker *string `type:"string"`++ // When a prefix is provided in the request, this field contains the specified+ // prefix. The result contains only keys starting with the specified prefix.+ Prefix *string `type:"string"`++ // Upload ID after which listing began.+ UploadIdMarker *string `type:"string"`++ Uploads []*MultipartUpload `locationName:"Upload" type:"list" flattened:"true"`+}++// String returns the string representation+func (s ListMultipartUploadsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListMultipartUploadsOutput) GoString() string {+ return s.String()+}++// SetBucket sets the Bucket field's value.+func (s *ListMultipartUploadsOutput) SetBucket(v string) *ListMultipartUploadsOutput {+ s.Bucket = &v+ return s+}++func (s *ListMultipartUploadsOutput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCommonPrefixes sets the CommonPrefixes field's value.+func (s *ListMultipartUploadsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListMultipartUploadsOutput {+ s.CommonPrefixes = v+ return s+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListMultipartUploadsOutput) SetDelimiter(v string) *ListMultipartUploadsOutput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListMultipartUploadsOutput) SetEncodingType(v string) *ListMultipartUploadsOutput {+ s.EncodingType = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListMultipartUploadsOutput) SetIsTruncated(v bool) *ListMultipartUploadsOutput {+ s.IsTruncated = &v+ return s+}++// SetKeyMarker sets the KeyMarker field's value.+func (s *ListMultipartUploadsOutput) SetKeyMarker(v string) *ListMultipartUploadsOutput {+ s.KeyMarker = &v+ return s+}++// SetMaxUploads sets the MaxUploads field's value.+func (s *ListMultipartUploadsOutput) SetMaxUploads(v int64) *ListMultipartUploadsOutput {+ s.MaxUploads = &v+ return s+}++// SetNextKeyMarker sets the NextKeyMarker field's value.+func (s *ListMultipartUploadsOutput) SetNextKeyMarker(v string) *ListMultipartUploadsOutput {+ s.NextKeyMarker = &v+ return s+}++// SetNextUploadIdMarker sets the NextUploadIdMarker field's value.+func (s *ListMultipartUploadsOutput) SetNextUploadIdMarker(v string) *ListMultipartUploadsOutput {+ s.NextUploadIdMarker = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListMultipartUploadsOutput) SetPrefix(v string) *ListMultipartUploadsOutput {+ s.Prefix = &v+ return s+}++// SetUploadIdMarker sets the UploadIdMarker field's value.+func (s *ListMultipartUploadsOutput) SetUploadIdMarker(v string) *ListMultipartUploadsOutput {+ s.UploadIdMarker = &v+ return s+}++// SetUploads sets the Uploads field's value.+func (s *ListMultipartUploadsOutput) SetUploads(v []*MultipartUpload) *ListMultipartUploadsOutput {+ s.Uploads = v+ return s+}++type ListObjectVersionsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // A delimiter is a character you use to group keys.+ Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`++ // Requests Amazon S3 to encode the object keys in the response and specifies+ // the encoding method to use. An object key may contain any Unicode character;+ // however, XML 1.0 parser cannot parse some characters, such as characters+ // with an ASCII value from 0 to 10. For characters that are not supported in+ // XML 1.0, you can add this parameter to request that Amazon S3 encode the+ // keys in the response.+ EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`++ // Specifies the key to start with when listing objects in a bucket.+ KeyMarker *string `location:"querystring" locationName:"key-marker" type:"string"`++ // Sets the maximum number of keys returned in the response. The response might+ // contain fewer keys but will never contain more.+ MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`++ // Limits the response to keys that begin with the specified prefix.+ Prefix *string `location:"querystring" locationName:"prefix" type:"string"`++ // Specifies the object version you want to start listing from.+ VersionIdMarker *string `location:"querystring" locationName:"version-id-marker" type:"string"`+}++// String returns the string representation+func (s ListObjectVersionsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectVersionsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListObjectVersionsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListObjectVersionsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListObjectVersionsInput) SetBucket(v string) *ListObjectVersionsInput {+ s.Bucket = &v+ return s+}++func (s *ListObjectVersionsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectVersionsInput) SetDelimiter(v string) *ListObjectVersionsInput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectVersionsInput) SetEncodingType(v string) *ListObjectVersionsInput {+ s.EncodingType = &v+ return s+}++// SetKeyMarker sets the KeyMarker field's value.+func (s *ListObjectVersionsInput) SetKeyMarker(v string) *ListObjectVersionsInput {+ s.KeyMarker = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectVersionsInput) SetMaxKeys(v int64) *ListObjectVersionsInput {+ s.MaxKeys = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectVersionsInput) SetPrefix(v string) *ListObjectVersionsInput {+ s.Prefix = &v+ return s+}++// SetVersionIdMarker sets the VersionIdMarker field's value.+func (s *ListObjectVersionsInput) SetVersionIdMarker(v string) *ListObjectVersionsInput {+ s.VersionIdMarker = &v+ return s+}++type ListObjectVersionsOutput struct {+ _ struct{} `type:"structure"`++ CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`++ DeleteMarkers []*DeleteMarkerEntry `locationName:"DeleteMarker" type:"list" flattened:"true"`++ Delimiter *string `type:"string"`++ // Encoding type used by Amazon S3 to encode object keys in the response.+ EncodingType *string `type:"string" enum:"EncodingType"`++ // A flag that indicates whether or not Amazon S3 returned all of the results+ // that satisfied the search criteria. If your results were truncated, you can+ // make a follow-up paginated request using the NextKeyMarker and NextVersionIdMarker+ // response parameters as a starting place in another request to return the+ // rest of the results.+ IsTruncated *bool `type:"boolean"`++ // Marks the last Key returned in a truncated response.+ KeyMarker *string `type:"string"`++ MaxKeys *int64 `type:"integer"`++ Name *string `type:"string"`++ // Use this value for the key marker request parameter in a subsequent request.+ NextKeyMarker *string `type:"string"`++ // Use this value for the next version id marker parameter in a subsequent request.+ NextVersionIdMarker *string `type:"string"`++ Prefix *string `type:"string"`++ VersionIdMarker *string `type:"string"`++ Versions []*ObjectVersion `locationName:"Version" type:"list" flattened:"true"`+}++// String returns the string representation+func (s ListObjectVersionsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectVersionsOutput) GoString() string {+ return s.String()+}++// SetCommonPrefixes sets the CommonPrefixes field's value.+func (s *ListObjectVersionsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListObjectVersionsOutput {+ s.CommonPrefixes = v+ return s+}++// SetDeleteMarkers sets the DeleteMarkers field's value.+func (s *ListObjectVersionsOutput) SetDeleteMarkers(v []*DeleteMarkerEntry) *ListObjectVersionsOutput {+ s.DeleteMarkers = v+ return s+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectVersionsOutput) SetDelimiter(v string) *ListObjectVersionsOutput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectVersionsOutput) SetEncodingType(v string) *ListObjectVersionsOutput {+ s.EncodingType = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListObjectVersionsOutput) SetIsTruncated(v bool) *ListObjectVersionsOutput {+ s.IsTruncated = &v+ return s+}++// SetKeyMarker sets the KeyMarker field's value.+func (s *ListObjectVersionsOutput) SetKeyMarker(v string) *ListObjectVersionsOutput {+ s.KeyMarker = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectVersionsOutput) SetMaxKeys(v int64) *ListObjectVersionsOutput {+ s.MaxKeys = &v+ return s+}++// SetName sets the Name field's value.+func (s *ListObjectVersionsOutput) SetName(v string) *ListObjectVersionsOutput {+ s.Name = &v+ return s+}++// SetNextKeyMarker sets the NextKeyMarker field's value.+func (s *ListObjectVersionsOutput) SetNextKeyMarker(v string) *ListObjectVersionsOutput {+ s.NextKeyMarker = &v+ return s+}++// SetNextVersionIdMarker sets the NextVersionIdMarker field's value.+func (s *ListObjectVersionsOutput) SetNextVersionIdMarker(v string) *ListObjectVersionsOutput {+ s.NextVersionIdMarker = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectVersionsOutput) SetPrefix(v string) *ListObjectVersionsOutput {+ s.Prefix = &v+ return s+}++// SetVersionIdMarker sets the VersionIdMarker field's value.+func (s *ListObjectVersionsOutput) SetVersionIdMarker(v string) *ListObjectVersionsOutput {+ s.VersionIdMarker = &v+ return s+}++// SetVersions sets the Versions field's value.+func (s *ListObjectVersionsOutput) SetVersions(v []*ObjectVersion) *ListObjectVersionsOutput {+ s.Versions = v+ return s+}++type ListObjectsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // A delimiter is a character you use to group keys.+ Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`++ // Requests Amazon S3 to encode the object keys in the response and specifies+ // the encoding method to use. An object key may contain any Unicode character;+ // however, XML 1.0 parser cannot parse some characters, such as characters+ // with an ASCII value from 0 to 10. For characters that are not supported in+ // XML 1.0, you can add this parameter to request that Amazon S3 encode the+ // keys in the response.+ EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`++ // Specifies the key to start with when listing objects in a bucket.+ Marker *string `location:"querystring" locationName:"marker" type:"string"`++ // Sets the maximum number of keys returned in the response. The response might+ // contain fewer keys but will never contain more.+ MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`++ // Limits the response to keys that begin with the specified prefix.+ Prefix *string `location:"querystring" locationName:"prefix" type:"string"`++ // Confirms that the requester knows that she or he will be charged for the+ // list objects request. Bucket owners need not specify this parameter in their+ // requests.+ RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`+}++// String returns the string representation+func (s ListObjectsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListObjectsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListObjectsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListObjectsInput) SetBucket(v string) *ListObjectsInput {+ s.Bucket = &v+ return s+}++func (s *ListObjectsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectsInput) SetDelimiter(v string) *ListObjectsInput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectsInput) SetEncodingType(v string) *ListObjectsInput {+ s.EncodingType = &v+ return s+}++// SetMarker sets the Marker field's value.+func (s *ListObjectsInput) SetMarker(v string) *ListObjectsInput {+ s.Marker = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectsInput) SetMaxKeys(v int64) *ListObjectsInput {+ s.MaxKeys = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectsInput) SetPrefix(v string) *ListObjectsInput {+ s.Prefix = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *ListObjectsInput) SetRequestPayer(v string) *ListObjectsInput {+ s.RequestPayer = &v+ return s+}++type ListObjectsOutput struct {+ _ struct{} `type:"structure"`++ CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`++ Contents []*Object `type:"list" flattened:"true"`++ Delimiter *string `type:"string"`++ // Encoding type used by Amazon S3 to encode object keys in the response.+ EncodingType *string `type:"string" enum:"EncodingType"`++ // A flag that indicates whether or not Amazon S3 returned all of the results+ // that satisfied the search criteria.+ IsTruncated *bool `type:"boolean"`++ Marker *string `type:"string"`++ MaxKeys *int64 `type:"integer"`++ Name *string `type:"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. Amazon S3 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.+ NextMarker *string `type:"string"`++ Prefix *string `type:"string"`+}++// String returns the string representation+func (s ListObjectsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectsOutput) GoString() string {+ return s.String()+}++// SetCommonPrefixes sets the CommonPrefixes field's value.+func (s *ListObjectsOutput) SetCommonPrefixes(v []*CommonPrefix) *ListObjectsOutput {+ s.CommonPrefixes = v+ return s+}++// SetContents sets the Contents field's value.+func (s *ListObjectsOutput) SetContents(v []*Object) *ListObjectsOutput {+ s.Contents = v+ return s+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectsOutput) SetDelimiter(v string) *ListObjectsOutput {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectsOutput) SetEncodingType(v string) *ListObjectsOutput {+ s.EncodingType = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListObjectsOutput) SetIsTruncated(v bool) *ListObjectsOutput {+ s.IsTruncated = &v+ return s+}++// SetMarker sets the Marker field's value.+func (s *ListObjectsOutput) SetMarker(v string) *ListObjectsOutput {+ s.Marker = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectsOutput) SetMaxKeys(v int64) *ListObjectsOutput {+ s.MaxKeys = &v+ return s+}++// SetName sets the Name field's value.+func (s *ListObjectsOutput) SetName(v string) *ListObjectsOutput {+ s.Name = &v+ return s+}++// SetNextMarker sets the NextMarker field's value.+func (s *ListObjectsOutput) SetNextMarker(v string) *ListObjectsOutput {+ s.NextMarker = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectsOutput) SetPrefix(v string) *ListObjectsOutput {+ s.Prefix = &v+ return s+}++type ListObjectsV2Input struct {+ _ struct{} `type:"structure"`++ // Name of the bucket to list.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // ContinuationToken indicates Amazon S3 that the list is being continued on+ // this bucket with a token. ContinuationToken is obfuscated and is not a real+ // key+ ContinuationToken *string `location:"querystring" locationName:"continuation-token" type:"string"`++ // A delimiter is a character you use to group keys.+ Delimiter *string `location:"querystring" locationName:"delimiter" type:"string"`++ // Encoding type used by Amazon S3 to encode object keys in the response.+ EncodingType *string `location:"querystring" locationName:"encoding-type" type:"string" enum:"EncodingType"`++ // The owner field is not present in listV2 by default, if you want to return+ // owner field with each key in the result then set the fetch owner field to+ // true+ FetchOwner *bool `location:"querystring" locationName:"fetch-owner" type:"boolean"`++ // Sets the maximum number of keys returned in the response. The response might+ // contain fewer keys but will never contain more.+ MaxKeys *int64 `location:"querystring" locationName:"max-keys" type:"integer"`++ // Limits the response to keys that begin with the specified prefix.+ Prefix *string `location:"querystring" locationName:"prefix" type:"string"`++ // Confirms that the requester knows that she or he will be charged for the+ // list objects request in V2 style. Bucket owners need not specify this parameter+ // in their requests.+ RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string" enum:"RequestPayer"`++ // StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts+ // listing after this specified key. StartAfter can be any key in the bucket+ StartAfter *string `location:"querystring" locationName:"start-after" type:"string"`+}++// String returns the string representation+func (s ListObjectsV2Input) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectsV2Input) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListObjectsV2Input) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListObjectsV2Input"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListObjectsV2Input) SetBucket(v string) *ListObjectsV2Input {+ s.Bucket = &v+ return s+}++func (s *ListObjectsV2Input) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListObjectsV2Input) SetContinuationToken(v string) *ListObjectsV2Input {+ s.ContinuationToken = &v+ return s+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectsV2Input) SetDelimiter(v string) *ListObjectsV2Input {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectsV2Input) SetEncodingType(v string) *ListObjectsV2Input {+ s.EncodingType = &v+ return s+}++// SetFetchOwner sets the FetchOwner field's value.+func (s *ListObjectsV2Input) SetFetchOwner(v bool) *ListObjectsV2Input {+ s.FetchOwner = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectsV2Input) SetMaxKeys(v int64) *ListObjectsV2Input {+ s.MaxKeys = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectsV2Input) SetPrefix(v string) *ListObjectsV2Input {+ s.Prefix = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *ListObjectsV2Input) SetRequestPayer(v string) *ListObjectsV2Input {+ s.RequestPayer = &v+ return s+}++// SetStartAfter sets the StartAfter field's value.+func (s *ListObjectsV2Input) SetStartAfter(v string) *ListObjectsV2Input {+ s.StartAfter = &v+ return s+}++type ListObjectsV2Output struct {+ _ struct{} `type:"structure"`++ // CommonPrefixes contains all (if there are any) keys between Prefix and the+ // next occurrence of the string specified by delimiter+ CommonPrefixes []*CommonPrefix `type:"list" flattened:"true"`++ // Metadata about each object returned.+ Contents []*Object `type:"list" flattened:"true"`++ // ContinuationToken indicates Amazon S3 that the list is being continued on+ // this bucket with a token. ContinuationToken is obfuscated and is not a real+ // key+ ContinuationToken *string `type:"string"`++ // A delimiter is a character you use to group keys.+ Delimiter *string `type:"string"`++ // Encoding type used by Amazon S3 to encode object keys in the response.+ EncodingType *string `type:"string" enum:"EncodingType"`++ // A flag that indicates whether or not Amazon S3 returned all of the results+ // that satisfied the search criteria.+ IsTruncated *bool `type:"boolean"`++ // KeyCount is the number of keys returned with this request. KeyCount will+ // always be less than equals to MaxKeys field. Say you ask for 50 keys, your+ // result will include less than equals 50 keys+ KeyCount *int64 `type:"integer"`++ // Sets the maximum number of keys returned in the response. The response might+ // contain fewer keys but will never contain more.+ MaxKeys *int64 `type:"integer"`++ // Name of the bucket to list.+ Name *string `type:"string"`++ // NextContinuationToken is sent when isTruncated is true which means there+ // are more keys in the bucket that can be listed. The next list requests to+ // Amazon S3 can be continued with this NextContinuationToken. NextContinuationToken+ // is obfuscated and is not a real key+ NextContinuationToken *string `type:"string"`++ // Limits the response to keys that begin with the specified prefix.+ Prefix *string `type:"string"`++ // StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts+ // listing after this specified key. StartAfter can be any key in the bucket+ StartAfter *string `type:"string"`+}++// String returns the string representation+func (s ListObjectsV2Output) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListObjectsV2Output) GoString() string {+ return s.String()+}++// SetCommonPrefixes sets the CommonPrefixes field's value.+func (s *ListObjectsV2Output) SetCommonPrefixes(v []*CommonPrefix) *ListObjectsV2Output {+ s.CommonPrefixes = v+ return s+}++// SetContents sets the Contents field's value.+func (s *ListObjectsV2Output) SetContents(v []*Object) *ListObjectsV2Output {+ s.Contents = v+ return s+}++// SetContinuationToken sets the ContinuationToken field's value.+func (s *ListObjectsV2Output) SetContinuationToken(v string) *ListObjectsV2Output {+ s.ContinuationToken = &v+ return s+}++// SetDelimiter sets the Delimiter field's value.+func (s *ListObjectsV2Output) SetDelimiter(v string) *ListObjectsV2Output {+ s.Delimiter = &v+ return s+}++// SetEncodingType sets the EncodingType field's value.+func (s *ListObjectsV2Output) SetEncodingType(v string) *ListObjectsV2Output {+ s.EncodingType = &v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListObjectsV2Output) SetIsTruncated(v bool) *ListObjectsV2Output {+ s.IsTruncated = &v+ return s+}++// SetKeyCount sets the KeyCount field's value.+func (s *ListObjectsV2Output) SetKeyCount(v int64) *ListObjectsV2Output {+ s.KeyCount = &v+ return s+}++// SetMaxKeys sets the MaxKeys field's value.+func (s *ListObjectsV2Output) SetMaxKeys(v int64) *ListObjectsV2Output {+ s.MaxKeys = &v+ return s+}++// SetName sets the Name field's value.+func (s *ListObjectsV2Output) SetName(v string) *ListObjectsV2Output {+ s.Name = &v+ return s+}++// SetNextContinuationToken sets the NextContinuationToken field's value.+func (s *ListObjectsV2Output) SetNextContinuationToken(v string) *ListObjectsV2Output {+ s.NextContinuationToken = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ListObjectsV2Output) SetPrefix(v string) *ListObjectsV2Output {+ s.Prefix = &v+ return s+}++// SetStartAfter sets the StartAfter field's value.+func (s *ListObjectsV2Output) SetStartAfter(v string) *ListObjectsV2Output {+ s.StartAfter = &v+ return s+}++type ListPartsInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Sets the maximum number of parts to return.+ MaxParts *int64 `location:"querystring" locationName:"max-parts" type:"integer"`++ // Specifies the part after which listing should begin. Only parts with higher+ // part numbers will be listed.+ PartNumberMarker *int64 `location:"querystring" locationName:"part-number-marker" type:"integer"`++ // 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" enum:"RequestPayer"`++ // Upload ID identifying the multipart upload whose parts are being listed.+ //+ // UploadId is a required field+ UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`+}++// String returns the string representation+func (s ListPartsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListPartsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ListPartsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ListPartsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.UploadId == nil {+ invalidParams.Add(request.NewErrParamRequired("UploadId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *ListPartsInput) SetBucket(v string) *ListPartsInput {+ s.Bucket = &v+ return s+}++func (s *ListPartsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *ListPartsInput) SetKey(v string) *ListPartsInput {+ s.Key = &v+ return s+}++// SetMaxParts sets the MaxParts field's value.+func (s *ListPartsInput) SetMaxParts(v int64) *ListPartsInput {+ s.MaxParts = &v+ return s+}++// SetPartNumberMarker sets the PartNumberMarker field's value.+func (s *ListPartsInput) SetPartNumberMarker(v int64) *ListPartsInput {+ s.PartNumberMarker = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *ListPartsInput) SetRequestPayer(v string) *ListPartsInput {+ s.RequestPayer = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *ListPartsInput) SetUploadId(v string) *ListPartsInput {+ s.UploadId = &v+ return s+}++type ListPartsOutput struct {+ _ struct{} `type:"structure"`++ // Date when multipart upload will become eligible for abort operation by lifecycle.+ AbortDate *time.Time `location:"header" locationName:"x-amz-abort-date" type:"timestamp"`++ // Id of the lifecycle rule that makes a multipart upload eligible for abort+ // operation.+ AbortRuleId *string `location:"header" locationName:"x-amz-abort-rule-id" type:"string"`++ // Name of the bucket to which the multipart upload was initiated.+ Bucket *string `type:"string"`++ // Identifies who initiated the multipart upload.+ Initiator *Initiator `type:"structure"`++ // Indicates whether the returned list of parts is truncated.+ IsTruncated *bool `type:"boolean"`++ // Object key for which the multipart upload was initiated.+ Key *string `min:"1" type:"string"`++ // Maximum number of parts that were allowed in the response.+ MaxParts *int64 `type:"integer"`++ // When a list is truncated, this element specifies the last part in the list,+ // as well as the value to use for the part-number-marker request parameter+ // in a subsequent request.+ NextPartNumberMarker *int64 `type:"integer"`++ Owner *Owner `type:"structure"`++ // Part number after which listing begins.+ PartNumberMarker *int64 `type:"integer"`++ Parts []*Part `locationName:"Part" type:"list" flattened:"true"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"StorageClass"`++ // Upload ID identifying the multipart upload whose parts are being listed.+ UploadId *string `type:"string"`+}++// String returns the string representation+func (s ListPartsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ListPartsOutput) GoString() string {+ return s.String()+}++// SetAbortDate sets the AbortDate field's value.+func (s *ListPartsOutput) SetAbortDate(v time.Time) *ListPartsOutput {+ s.AbortDate = &v+ return s+}++// SetAbortRuleId sets the AbortRuleId field's value.+func (s *ListPartsOutput) SetAbortRuleId(v string) *ListPartsOutput {+ s.AbortRuleId = &v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *ListPartsOutput) SetBucket(v string) *ListPartsOutput {+ s.Bucket = &v+ return s+}++func (s *ListPartsOutput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetInitiator sets the Initiator field's value.+func (s *ListPartsOutput) SetInitiator(v *Initiator) *ListPartsOutput {+ s.Initiator = v+ return s+}++// SetIsTruncated sets the IsTruncated field's value.+func (s *ListPartsOutput) SetIsTruncated(v bool) *ListPartsOutput {+ s.IsTruncated = &v+ return s+}++// SetKey sets the Key field's value.+func (s *ListPartsOutput) SetKey(v string) *ListPartsOutput {+ s.Key = &v+ return s+}++// SetMaxParts sets the MaxParts field's value.+func (s *ListPartsOutput) SetMaxParts(v int64) *ListPartsOutput {+ s.MaxParts = &v+ return s+}++// SetNextPartNumberMarker sets the NextPartNumberMarker field's value.+func (s *ListPartsOutput) SetNextPartNumberMarker(v int64) *ListPartsOutput {+ s.NextPartNumberMarker = &v+ return s+}++// SetOwner sets the Owner field's value.+func (s *ListPartsOutput) SetOwner(v *Owner) *ListPartsOutput {+ s.Owner = v+ return s+}++// SetPartNumberMarker sets the PartNumberMarker field's value.+func (s *ListPartsOutput) SetPartNumberMarker(v int64) *ListPartsOutput {+ s.PartNumberMarker = &v+ return s+}++// SetParts sets the Parts field's value.+func (s *ListPartsOutput) SetParts(v []*Part) *ListPartsOutput {+ s.Parts = v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *ListPartsOutput) SetRequestCharged(v string) *ListPartsOutput {+ s.RequestCharged = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *ListPartsOutput) SetStorageClass(v string) *ListPartsOutput {+ s.StorageClass = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *ListPartsOutput) SetUploadId(v string) *ListPartsOutput {+ s.UploadId = &v+ return s+}++// Describes an S3 location that will receive the results of the restore request.+type Location struct {+ _ struct{} `type:"structure"`++ // A list of grants that control access to the staged results.+ AccessControlList []*Grant `locationNameList:"Grant" type:"list"`++ // The name of the bucket where the restore results will be placed.+ //+ // BucketName is a required field+ BucketName *string `type:"string" required:"true"`++ // The canned ACL to apply to the restore results.+ CannedACL *string `type:"string" enum:"ObjectCannedACL"`++ // Describes the server-side encryption that will be applied to the restore+ // results.+ Encryption *Encryption `type:"structure"`++ // The prefix that is prepended to the restore results for this request.+ //+ // Prefix is a required field+ Prefix *string `type:"string" required:"true"`++ // The class of storage used to store the restore results.+ StorageClass *string `type:"string" enum:"StorageClass"`++ // The tag-set that is applied to the restore results.+ Tagging *Tagging `type:"structure"`++ // A list of metadata to store with the restore results in S3.+ UserMetadata []*MetadataEntry `locationNameList:"MetadataEntry" type:"list"`+}++// String returns the string representation+func (s Location) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Location) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Location) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Location"}+ if s.BucketName == nil {+ invalidParams.Add(request.NewErrParamRequired("BucketName"))+ }+ if s.Prefix == nil {+ invalidParams.Add(request.NewErrParamRequired("Prefix"))+ }+ if s.AccessControlList != nil {+ for i, v := range s.AccessControlList {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "AccessControlList", i), err.(request.ErrInvalidParams))+ }+ }+ }+ if s.Encryption != nil {+ if err := s.Encryption.Validate(); err != nil {+ invalidParams.AddNested("Encryption", err.(request.ErrInvalidParams))+ }+ }+ if s.Tagging != nil {+ if err := s.Tagging.Validate(); err != nil {+ invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAccessControlList sets the AccessControlList field's value.+func (s *Location) SetAccessControlList(v []*Grant) *Location {+ s.AccessControlList = v+ return s+}++// SetBucketName sets the BucketName field's value.+func (s *Location) SetBucketName(v string) *Location {+ s.BucketName = &v+ return s+}++// SetCannedACL sets the CannedACL field's value.+func (s *Location) SetCannedACL(v string) *Location {+ s.CannedACL = &v+ return s+}++// SetEncryption sets the Encryption field's value.+func (s *Location) SetEncryption(v *Encryption) *Location {+ s.Encryption = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *Location) SetPrefix(v string) *Location {+ s.Prefix = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *Location) SetStorageClass(v string) *Location {+ s.StorageClass = &v+ return s+}++// SetTagging sets the Tagging field's value.+func (s *Location) SetTagging(v *Tagging) *Location {+ s.Tagging = v+ return s+}++// SetUserMetadata sets the UserMetadata field's value.+func (s *Location) SetUserMetadata(v []*MetadataEntry) *Location {+ s.UserMetadata = v+ return s+}++// Container for logging information. Presence of this element indicates that+// logging is enabled. Parameters TargetBucket and TargetPrefix are required+// in this case.+type LoggingEnabled struct {+ _ struct{} `type:"structure"`++ // Specifies the bucket where you want Amazon S3 to store server access logs.+ // You can have your logs delivered to any bucket that you own, including the+ // same bucket that is being logged. You can also configure multiple buckets+ // to deliver their logs to the same target bucket. In this case you should+ // choose a different TargetPrefix for each source bucket so that the delivered+ // log files can be distinguished by key.+ //+ // TargetBucket is a required field+ TargetBucket *string `type:"string" required:"true"`++ TargetGrants []*TargetGrant `locationNameList:"Grant" type:"list"`++ // This element lets you specify a prefix for the keys that the log files will+ // be stored under.+ //+ // TargetPrefix is a required field+ TargetPrefix *string `type:"string" required:"true"`+}++// String returns the string representation+func (s LoggingEnabled) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s LoggingEnabled) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *LoggingEnabled) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "LoggingEnabled"}+ if s.TargetBucket == nil {+ invalidParams.Add(request.NewErrParamRequired("TargetBucket"))+ }+ if s.TargetPrefix == nil {+ invalidParams.Add(request.NewErrParamRequired("TargetPrefix"))+ }+ if s.TargetGrants != nil {+ for i, v := range s.TargetGrants {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TargetGrants", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetTargetBucket sets the TargetBucket field's value.+func (s *LoggingEnabled) SetTargetBucket(v string) *LoggingEnabled {+ s.TargetBucket = &v+ return s+}++// SetTargetGrants sets the TargetGrants field's value.+func (s *LoggingEnabled) SetTargetGrants(v []*TargetGrant) *LoggingEnabled {+ s.TargetGrants = v+ return s+}++// SetTargetPrefix sets the TargetPrefix field's value.+func (s *LoggingEnabled) SetTargetPrefix(v string) *LoggingEnabled {+ s.TargetPrefix = &v+ return s+}++// A metadata key-value pair to store with an object.+type MetadataEntry struct {+ _ struct{} `type:"structure"`++ Name *string `type:"string"`++ Value *string `type:"string"`+}++// String returns the string representation+func (s MetadataEntry) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s MetadataEntry) GoString() string {+ return s.String()+}++// SetName sets the Name field's value.+func (s *MetadataEntry) SetName(v string) *MetadataEntry {+ s.Name = &v+ return s+}++// SetValue sets the Value field's value.+func (s *MetadataEntry) SetValue(v string) *MetadataEntry {+ s.Value = &v+ return s+}++type MetricsAndOperator struct {+ _ struct{} `type:"structure"`++ // The prefix used when evaluating an AND predicate.+ Prefix *string `type:"string"`++ // The list of tags used when evaluating an AND predicate.+ Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`+}++// String returns the string representation+func (s MetricsAndOperator) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s MetricsAndOperator) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *MetricsAndOperator) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "MetricsAndOperator"}+ if s.Tags != nil {+ for i, v := range s.Tags {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPrefix sets the Prefix field's value.+func (s *MetricsAndOperator) SetPrefix(v string) *MetricsAndOperator {+ s.Prefix = &v+ return s+}++// SetTags sets the Tags field's value.+func (s *MetricsAndOperator) SetTags(v []*Tag) *MetricsAndOperator {+ s.Tags = v+ return s+}++type MetricsConfiguration struct {+ _ struct{} `type:"structure"`++ // Specifies a metrics configuration filter. The metrics configuration will+ // only include objects that meet the filter's criteria. A filter must be a+ // prefix, a tag, or a conjunction (MetricsAndOperator).+ Filter *MetricsFilter `type:"structure"`++ // The ID used to identify the metrics configuration.+ //+ // Id is a required field+ Id *string `type:"string" required:"true"`+}++// String returns the string representation+func (s MetricsConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s MetricsConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *MetricsConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "MetricsConfiguration"}+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.Filter != nil {+ if err := s.Filter.Validate(); err != nil {+ invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetFilter sets the Filter field's value.+func (s *MetricsConfiguration) SetFilter(v *MetricsFilter) *MetricsConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *MetricsConfiguration) SetId(v string) *MetricsConfiguration {+ s.Id = &v+ return s+}++type MetricsFilter struct {+ _ struct{} `type:"structure"`++ // A conjunction (logical AND) of predicates, which is used in evaluating a+ // metrics filter. The operator must have at least two predicates, and an object+ // must match all of the predicates in order for the filter to apply.+ And *MetricsAndOperator `type:"structure"`++ // The prefix used when evaluating a metrics filter.+ Prefix *string `type:"string"`++ // The tag used when evaluating a metrics filter.+ Tag *Tag `type:"structure"`+}++// String returns the string representation+func (s MetricsFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s MetricsFilter) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *MetricsFilter) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "MetricsFilter"}+ if s.And != nil {+ if err := s.And.Validate(); err != nil {+ invalidParams.AddNested("And", err.(request.ErrInvalidParams))+ }+ }+ if s.Tag != nil {+ if err := s.Tag.Validate(); err != nil {+ invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAnd sets the And field's value.+func (s *MetricsFilter) SetAnd(v *MetricsAndOperator) *MetricsFilter {+ s.And = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *MetricsFilter) SetPrefix(v string) *MetricsFilter {+ s.Prefix = &v+ return s+}++// SetTag sets the Tag field's value.+func (s *MetricsFilter) SetTag(v *Tag) *MetricsFilter {+ s.Tag = v+ return s+}++type MultipartUpload struct {+ _ struct{} `type:"structure"`++ // Date and time at which the multipart upload was initiated.+ Initiated *time.Time `type:"timestamp"`++ // Identifies who initiated the multipart upload.+ Initiator *Initiator `type:"structure"`++ // Key of the object for which the multipart upload was initiated.+ Key *string `min:"1" type:"string"`++ Owner *Owner `type:"structure"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"StorageClass"`++ // Upload ID that identifies the multipart upload.+ UploadId *string `type:"string"`+}++// String returns the string representation+func (s MultipartUpload) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s MultipartUpload) GoString() string {+ return s.String()+}++// SetInitiated sets the Initiated field's value.+func (s *MultipartUpload) SetInitiated(v time.Time) *MultipartUpload {+ s.Initiated = &v+ return s+}++// SetInitiator sets the Initiator field's value.+func (s *MultipartUpload) SetInitiator(v *Initiator) *MultipartUpload {+ s.Initiator = v+ return s+}++// SetKey sets the Key field's value.+func (s *MultipartUpload) SetKey(v string) *MultipartUpload {+ s.Key = &v+ return s+}++// SetOwner sets the Owner field's value.+func (s *MultipartUpload) SetOwner(v *Owner) *MultipartUpload {+ s.Owner = v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *MultipartUpload) SetStorageClass(v string) *MultipartUpload {+ s.StorageClass = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *MultipartUpload) SetUploadId(v string) *MultipartUpload {+ s.UploadId = &v+ return s+}++// Specifies when noncurrent object versions expire. Upon expiration, Amazon+// S3 permanently deletes the noncurrent object versions. You set this lifecycle+// configuration action on a bucket that has versioning enabled (or suspended)+// to request that Amazon S3 delete noncurrent object versions at a specific+// period in the object's lifetime.+type NoncurrentVersionExpiration struct {+ _ struct{} `type:"structure"`++ // Specifies the number of days an object is noncurrent before Amazon S3 can+ // perform the associated action. For information about the noncurrent days+ // calculations, see How Amazon S3 Calculates When an Object Became Noncurrent+ // (http://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html) in+ // the Amazon Simple Storage Service Developer Guide.+ NoncurrentDays *int64 `type:"integer"`+}++// String returns the string representation+func (s NoncurrentVersionExpiration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s NoncurrentVersionExpiration) GoString() string {+ return s.String()+}++// SetNoncurrentDays sets the NoncurrentDays field's value.+func (s *NoncurrentVersionExpiration) SetNoncurrentDays(v int64) *NoncurrentVersionExpiration {+ s.NoncurrentDays = &v+ return s+}++// Container for the transition rule that describes when noncurrent objects+// transition to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING or GLACIER+// storage class. If your bucket is versioning-enabled (or versioning is suspended),+// you can set this action to request that Amazon S3 transition noncurrent object+// versions to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING or GLACIER storage+// class at a specific period in the object's lifetime.+type NoncurrentVersionTransition struct {+ _ struct{} `type:"structure"`++ // Specifies the number of days an object is noncurrent before Amazon S3 can+ // perform the associated action. For information about the noncurrent days+ // calculations, see How Amazon S3 Calculates When an Object Became Noncurrent+ // (http://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html) in+ // the Amazon Simple Storage Service Developer Guide.+ NoncurrentDays *int64 `type:"integer"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"TransitionStorageClass"`+}++// String returns the string representation+func (s NoncurrentVersionTransition) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s NoncurrentVersionTransition) GoString() string {+ return s.String()+}++// SetNoncurrentDays sets the NoncurrentDays field's value.+func (s *NoncurrentVersionTransition) SetNoncurrentDays(v int64) *NoncurrentVersionTransition {+ s.NoncurrentDays = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *NoncurrentVersionTransition) SetStorageClass(v string) *NoncurrentVersionTransition {+ s.StorageClass = &v+ return s+}++// A container for specifying the notification configuration of the bucket.+// If this element is empty, notifications are turned off for the bucket.+type NotificationConfiguration struct {+ _ struct{} `type:"structure"`++ LambdaFunctionConfigurations []*LambdaFunctionConfiguration `locationName:"CloudFunctionConfiguration" type:"list" flattened:"true"`++ QueueConfigurations []*QueueConfiguration `locationName:"QueueConfiguration" type:"list" flattened:"true"`++ TopicConfigurations []*TopicConfiguration `locationName:"TopicConfiguration" type:"list" flattened:"true"`+}++// String returns the string representation+func (s NotificationConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s NotificationConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *NotificationConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "NotificationConfiguration"}+ if s.LambdaFunctionConfigurations != nil {+ for i, v := range s.LambdaFunctionConfigurations {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "LambdaFunctionConfigurations", i), err.(request.ErrInvalidParams))+ }+ }+ }+ if s.QueueConfigurations != nil {+ for i, v := range s.QueueConfigurations {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "QueueConfigurations", i), err.(request.ErrInvalidParams))+ }+ }+ }+ if s.TopicConfigurations != nil {+ for i, v := range s.TopicConfigurations {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TopicConfigurations", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetLambdaFunctionConfigurations sets the LambdaFunctionConfigurations field's value.+func (s *NotificationConfiguration) SetLambdaFunctionConfigurations(v []*LambdaFunctionConfiguration) *NotificationConfiguration {+ s.LambdaFunctionConfigurations = v+ return s+}++// SetQueueConfigurations sets the QueueConfigurations field's value.+func (s *NotificationConfiguration) SetQueueConfigurations(v []*QueueConfiguration) *NotificationConfiguration {+ s.QueueConfigurations = v+ return s+}++// SetTopicConfigurations sets the TopicConfigurations field's value.+func (s *NotificationConfiguration) SetTopicConfigurations(v []*TopicConfiguration) *NotificationConfiguration {+ s.TopicConfigurations = v+ return s+}++type NotificationConfigurationDeprecated struct {+ _ struct{} `type:"structure"`++ CloudFunctionConfiguration *CloudFunctionConfiguration `type:"structure"`++ QueueConfiguration *QueueConfigurationDeprecated `type:"structure"`++ TopicConfiguration *TopicConfigurationDeprecated `type:"structure"`+}++// String returns the string representation+func (s NotificationConfigurationDeprecated) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s NotificationConfigurationDeprecated) GoString() string {+ return s.String()+}++// SetCloudFunctionConfiguration sets the CloudFunctionConfiguration field's value.+func (s *NotificationConfigurationDeprecated) SetCloudFunctionConfiguration(v *CloudFunctionConfiguration) *NotificationConfigurationDeprecated {+ s.CloudFunctionConfiguration = v+ return s+}++// SetQueueConfiguration sets the QueueConfiguration field's value.+func (s *NotificationConfigurationDeprecated) SetQueueConfiguration(v *QueueConfigurationDeprecated) *NotificationConfigurationDeprecated {+ s.QueueConfiguration = v+ return s+}++// SetTopicConfiguration sets the TopicConfiguration field's value.+func (s *NotificationConfigurationDeprecated) SetTopicConfiguration(v *TopicConfigurationDeprecated) *NotificationConfigurationDeprecated {+ s.TopicConfiguration = v+ return s+}++// A container for object key name filtering rules. For information about key+// name filtering, see Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)+// in the Amazon Simple Storage Service Developer Guide.+type NotificationConfigurationFilter struct {+ _ struct{} `type:"structure"`++ // A container for object key name prefix and suffix filtering rules.+ Key *KeyFilter `locationName:"S3Key" type:"structure"`+}++// String returns the string representation+func (s NotificationConfigurationFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s NotificationConfigurationFilter) GoString() string {+ return s.String()+}++// SetKey sets the Key field's value.+func (s *NotificationConfigurationFilter) SetKey(v *KeyFilter) *NotificationConfigurationFilter {+ s.Key = v+ return s+}++type Object struct {+ _ struct{} `type:"structure"`++ ETag *string `type:"string"`++ Key *string `min:"1" type:"string"`++ LastModified *time.Time `type:"timestamp"`++ Owner *Owner `type:"structure"`++ Size *int64 `type:"integer"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"ObjectStorageClass"`+}++// String returns the string representation+func (s Object) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Object) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *Object) SetETag(v string) *Object {+ s.ETag = &v+ return s+}++// SetKey sets the Key field's value.+func (s *Object) SetKey(v string) *Object {+ s.Key = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *Object) SetLastModified(v time.Time) *Object {+ s.LastModified = &v+ return s+}++// SetOwner sets the Owner field's value.+func (s *Object) SetOwner(v *Owner) *Object {+ s.Owner = v+ return s+}++// SetSize sets the Size field's value.+func (s *Object) SetSize(v int64) *Object {+ s.Size = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *Object) SetStorageClass(v string) *Object {+ s.StorageClass = &v+ return s+}++type ObjectIdentifier struct {+ _ struct{} `type:"structure"`++ // Key name of the object to delete.+ //+ // Key is a required field+ Key *string `min:"1" type:"string" required:"true"`++ // VersionId for the specific version of the object to delete.+ VersionId *string `type:"string"`+}++// String returns the string representation+func (s ObjectIdentifier) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectIdentifier) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ObjectIdentifier) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ObjectIdentifier"}+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetKey sets the Key field's value.+func (s *ObjectIdentifier) SetKey(v string) *ObjectIdentifier {+ s.Key = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *ObjectIdentifier) SetVersionId(v string) *ObjectIdentifier {+ s.VersionId = &v+ return s+}++// The container element for Object Lock configuration parameters.+type ObjectLockConfiguration struct {+ _ struct{} `type:"structure"`++ // Indicates whether this bucket has an Object Lock configuration enabled.+ ObjectLockEnabled *string `type:"string" enum:"ObjectLockEnabled"`++ // The Object Lock rule in place for the specified object.+ Rule *ObjectLockRule `type:"structure"`+}++// String returns the string representation+func (s ObjectLockConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectLockConfiguration) GoString() string {+ return s.String()+}++// SetObjectLockEnabled sets the ObjectLockEnabled field's value.+func (s *ObjectLockConfiguration) SetObjectLockEnabled(v string) *ObjectLockConfiguration {+ s.ObjectLockEnabled = &v+ return s+}++// SetRule sets the Rule field's value.+func (s *ObjectLockConfiguration) SetRule(v *ObjectLockRule) *ObjectLockConfiguration {+ s.Rule = v+ return s+}++// A Legal Hold configuration for an object.+type ObjectLockLegalHold struct {+ _ struct{} `type:"structure"`++ // Indicates whether the specified object has a Legal Hold in place.+ Status *string `type:"string" enum:"ObjectLockLegalHoldStatus"`+}++// String returns the string representation+func (s ObjectLockLegalHold) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectLockLegalHold) GoString() string {+ return s.String()+}++// SetStatus sets the Status field's value.+func (s *ObjectLockLegalHold) SetStatus(v string) *ObjectLockLegalHold {+ s.Status = &v+ return s+}++// A Retention configuration for an object.+type ObjectLockRetention struct {+ _ struct{} `type:"structure"`++ // Indicates the Retention mode for the specified object.+ Mode *string `type:"string" enum:"ObjectLockRetentionMode"`++ // The date on which this Object Lock Retention will expire.+ RetainUntilDate *time.Time `type:"timestamp" timestampFormat:"iso8601"`+}++// String returns the string representation+func (s ObjectLockRetention) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectLockRetention) GoString() string {+ return s.String()+}++// SetMode sets the Mode field's value.+func (s *ObjectLockRetention) SetMode(v string) *ObjectLockRetention {+ s.Mode = &v+ return s+}++// SetRetainUntilDate sets the RetainUntilDate field's value.+func (s *ObjectLockRetention) SetRetainUntilDate(v time.Time) *ObjectLockRetention {+ s.RetainUntilDate = &v+ return s+}++// The container element for an Object Lock rule.+type ObjectLockRule struct {+ _ struct{} `type:"structure"`++ // The default retention period that you want to apply to new objects placed+ // in the specified bucket.+ DefaultRetention *DefaultRetention `type:"structure"`+}++// String returns the string representation+func (s ObjectLockRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectLockRule) GoString() string {+ return s.String()+}++// SetDefaultRetention sets the DefaultRetention field's value.+func (s *ObjectLockRule) SetDefaultRetention(v *DefaultRetention) *ObjectLockRule {+ s.DefaultRetention = v+ return s+}++type ObjectVersion struct {+ _ struct{} `type:"structure"`++ ETag *string `type:"string"`++ // Specifies whether the object is (true) or is not (false) the latest version+ // of an object.+ IsLatest *bool `type:"boolean"`++ // The object key.+ Key *string `min:"1" type:"string"`++ // Date and time the object was last modified.+ LastModified *time.Time `type:"timestamp"`++ Owner *Owner `type:"structure"`++ // Size in bytes of the object.+ Size *int64 `type:"integer"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"ObjectVersionStorageClass"`++ // Version ID of an object.+ VersionId *string `type:"string"`+}++// String returns the string representation+func (s ObjectVersion) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ObjectVersion) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *ObjectVersion) SetETag(v string) *ObjectVersion {+ s.ETag = &v+ return s+}++// SetIsLatest sets the IsLatest field's value.+func (s *ObjectVersion) SetIsLatest(v bool) *ObjectVersion {+ s.IsLatest = &v+ return s+}++// SetKey sets the Key field's value.+func (s *ObjectVersion) SetKey(v string) *ObjectVersion {+ s.Key = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *ObjectVersion) SetLastModified(v time.Time) *ObjectVersion {+ s.LastModified = &v+ return s+}++// SetOwner sets the Owner field's value.+func (s *ObjectVersion) SetOwner(v *Owner) *ObjectVersion {+ s.Owner = v+ return s+}++// SetSize sets the Size field's value.+func (s *ObjectVersion) SetSize(v int64) *ObjectVersion {+ s.Size = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *ObjectVersion) SetStorageClass(v string) *ObjectVersion {+ s.StorageClass = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *ObjectVersion) SetVersionId(v string) *ObjectVersion {+ s.VersionId = &v+ return s+}++// Describes the location where the restore job's output is stored.+type OutputLocation struct {+ _ struct{} `type:"structure"`++ // Describes an S3 location that will receive the results of the restore request.+ S3 *Location `type:"structure"`+}++// String returns the string representation+func (s OutputLocation) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s OutputLocation) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *OutputLocation) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "OutputLocation"}+ if s.S3 != nil {+ if err := s.S3.Validate(); err != nil {+ invalidParams.AddNested("S3", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetS3 sets the S3 field's value.+func (s *OutputLocation) SetS3(v *Location) *OutputLocation {+ s.S3 = v+ return s+}++// Describes how results of the Select job are serialized.+type OutputSerialization struct {+ _ struct{} `type:"structure"`++ // Describes the serialization of CSV-encoded Select results.+ CSV *CSVOutput `type:"structure"`++ // Specifies JSON as request's output serialization format.+ JSON *JSONOutput `type:"structure"`+}++// String returns the string representation+func (s OutputSerialization) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s OutputSerialization) GoString() string {+ return s.String()+}++// SetCSV sets the CSV field's value.+func (s *OutputSerialization) SetCSV(v *CSVOutput) *OutputSerialization {+ s.CSV = v+ return s+}++// SetJSON sets the JSON field's value.+func (s *OutputSerialization) SetJSON(v *JSONOutput) *OutputSerialization {+ s.JSON = v+ return s+}++type Owner struct {+ _ struct{} `type:"structure"`++ DisplayName *string `type:"string"`++ ID *string `type:"string"`+}++// String returns the string representation+func (s Owner) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Owner) GoString() string {+ return s.String()+}++// SetDisplayName sets the DisplayName field's value.+func (s *Owner) SetDisplayName(v string) *Owner {+ s.DisplayName = &v+ return s+}++// SetID sets the ID field's value.+func (s *Owner) SetID(v string) *Owner {+ s.ID = &v+ return s+}++type ParquetInput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s ParquetInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ParquetInput) GoString() string {+ return s.String()+}++type Part struct {+ _ struct{} `type:"structure"`++ // Entity tag returned when the part was uploaded.+ ETag *string `type:"string"`++ // Date and time at which the part was uploaded.+ LastModified *time.Time `type:"timestamp"`++ // Part number identifying the part. This is a positive integer between 1 and+ // 10,000.+ PartNumber *int64 `type:"integer"`++ // Size in bytes of the uploaded part data.+ Size *int64 `type:"integer"`+}++// String returns the string representation+func (s Part) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Part) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *Part) SetETag(v string) *Part {+ s.ETag = &v+ return s+}++// SetLastModified sets the LastModified field's value.+func (s *Part) SetLastModified(v time.Time) *Part {+ s.LastModified = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *Part) SetPartNumber(v int64) *Part {+ s.PartNumber = &v+ return s+}++// SetSize sets the Size field's value.+func (s *Part) SetSize(v int64) *Part {+ s.Size = &v+ return s+}++// The container element for a bucket's policy status.+type PolicyStatus struct {+ _ struct{} `type:"structure"`++ // The policy status for this bucket. TRUE indicates that this bucket is public.+ // FALSE indicates that the bucket is not public.+ IsPublic *bool `locationName:"IsPublic" type:"boolean"`+}++// String returns the string representation+func (s PolicyStatus) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PolicyStatus) GoString() string {+ return s.String()+}++// SetIsPublic sets the IsPublic field's value.+func (s *PolicyStatus) SetIsPublic(v bool) *PolicyStatus {+ s.IsPublic = &v+ return s+}++type Progress struct {+ _ struct{} `type:"structure"`++ // The current number of uncompressed object bytes processed.+ BytesProcessed *int64 `type:"long"`++ // The current number of bytes of records payload data returned.+ BytesReturned *int64 `type:"long"`++ // The current number of object bytes scanned.+ BytesScanned *int64 `type:"long"`+}++// String returns the string representation+func (s Progress) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Progress) GoString() string {+ return s.String()+}++// SetBytesProcessed sets the BytesProcessed field's value.+func (s *Progress) SetBytesProcessed(v int64) *Progress {+ s.BytesProcessed = &v+ return s+}++// SetBytesReturned sets the BytesReturned field's value.+func (s *Progress) SetBytesReturned(v int64) *Progress {+ s.BytesReturned = &v+ return s+}++// SetBytesScanned sets the BytesScanned field's value.+func (s *Progress) SetBytesScanned(v int64) *Progress {+ s.BytesScanned = &v+ return s+}++type ProgressEvent struct {+ _ struct{} `locationName:"ProgressEvent" type:"structure" payload:"Details"`++ // The Progress event details.+ Details *Progress `locationName:"Details" type:"structure"`+}++// String returns the string representation+func (s ProgressEvent) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ProgressEvent) GoString() string {+ return s.String()+}++// SetDetails sets the Details field's value.+func (s *ProgressEvent) SetDetails(v *Progress) *ProgressEvent {+ s.Details = v+ return s+}++// The ProgressEvent is and event in the SelectObjectContentEventStream group of events.+func (s *ProgressEvent) eventSelectObjectContentEventStream() {}++// UnmarshalEvent unmarshals the EventStream Message into the ProgressEvent value.+// This method is only used internally within the SDK's EventStream handling.+func (s *ProgressEvent) UnmarshalEvent(+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ msg eventstream.Message,+) error {+ if err := payloadUnmarshaler.UnmarshalPayload(+ bytes.NewReader(msg.Payload), s,+ ); err != nil {+ return err+ }+ return nil+}++type PublicAccessBlockConfiguration struct {+ _ struct{} `type:"structure"`++ // Specifies whether Amazon S3 should block public access control lists (ACLs)+ // for this bucket and objects in this bucket. Setting this element to TRUE+ // causes the following behavior:+ //+ // * PUT Bucket acl and PUT Object acl calls fail if the specified ACL is+ // public.+ //+ // * PUT Object calls fail if the request includes a public ACL.+ //+ // Enabling this setting doesn't affect existing policies or ACLs.+ BlockPublicAcls *bool `locationName:"BlockPublicAcls" type:"boolean"`++ // Specifies whether Amazon S3 should block public bucket policies for this+ // bucket. Setting this element to TRUE causes Amazon S3 to reject calls to+ // PUT Bucket policy if the specified bucket policy allows public access.+ //+ // Enabling this setting doesn't affect existing bucket policies.+ BlockPublicPolicy *bool `locationName:"BlockPublicPolicy" type:"boolean"`++ // Specifies whether Amazon S3 should ignore public ACLs for this bucket and+ // objects in this bucket. Setting this element to TRUE causes Amazon S3 to+ // ignore all public ACLs on this bucket and objects in this bucket.+ //+ // Enabling this setting doesn't affect the persistence of any existing ACLs+ // and doesn't prevent new public ACLs from being set.+ IgnorePublicAcls *bool `locationName:"IgnorePublicAcls" type:"boolean"`++ // Specifies whether Amazon S3 should restrict public bucket policies for this+ // bucket. Setting this element to TRUE restricts access to this bucket to only+ // AWS services and authorized users within this account if the bucket has a+ // public policy.+ //+ // Enabling this setting doesn't affect previously stored bucket policies, except+ // that public and cross-account access within any public bucket policy, including+ // non-public delegation to specific accounts, is blocked.+ RestrictPublicBuckets *bool `locationName:"RestrictPublicBuckets" type:"boolean"`+}++// String returns the string representation+func (s PublicAccessBlockConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PublicAccessBlockConfiguration) GoString() string {+ return s.String()+}++// SetBlockPublicAcls sets the BlockPublicAcls field's value.+func (s *PublicAccessBlockConfiguration) SetBlockPublicAcls(v bool) *PublicAccessBlockConfiguration {+ s.BlockPublicAcls = &v+ return s+}++// SetBlockPublicPolicy sets the BlockPublicPolicy field's value.+func (s *PublicAccessBlockConfiguration) SetBlockPublicPolicy(v bool) *PublicAccessBlockConfiguration {+ s.BlockPublicPolicy = &v+ return s+}++// SetIgnorePublicAcls sets the IgnorePublicAcls field's value.+func (s *PublicAccessBlockConfiguration) SetIgnorePublicAcls(v bool) *PublicAccessBlockConfiguration {+ s.IgnorePublicAcls = &v+ return s+}++// SetRestrictPublicBuckets sets the RestrictPublicBuckets field's value.+func (s *PublicAccessBlockConfiguration) SetRestrictPublicBuckets(v bool) *PublicAccessBlockConfiguration {+ s.RestrictPublicBuckets = &v+ return s+}++type PutBucketAccelerateConfigurationInput struct {+ _ struct{} `type:"structure" payload:"AccelerateConfiguration"`++ // Specifies the Accelerate Configuration you want to set for the bucket.+ //+ // AccelerateConfiguration is a required field+ AccelerateConfiguration *AccelerateConfiguration `locationName:"AccelerateConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // Name of the bucket for which the accelerate configuration is set.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`+}++// String returns the string representation+func (s PutBucketAccelerateConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAccelerateConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketAccelerateConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketAccelerateConfigurationInput"}+ if s.AccelerateConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("AccelerateConfiguration"))+ }+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAccelerateConfiguration sets the AccelerateConfiguration field's value.+func (s *PutBucketAccelerateConfigurationInput) SetAccelerateConfiguration(v *AccelerateConfiguration) *PutBucketAccelerateConfigurationInput {+ s.AccelerateConfiguration = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketAccelerateConfigurationInput) SetBucket(v string) *PutBucketAccelerateConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketAccelerateConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++type PutBucketAccelerateConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketAccelerateConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAccelerateConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketAclInput struct {+ _ struct{} `type:"structure" payload:"AccessControlPolicy"`++ // The canned ACL to apply to the bucket.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"BucketCannedACL"`++ AccessControlPolicy *AccessControlPolicy `locationName:"AccessControlPolicy" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Allows grantee the read, write, read ACP, and write ACP permissions on the+ // bucket.+ GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`++ // Allows grantee to list the objects in the bucket.+ GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`++ // Allows grantee to read the bucket ACL.+ GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`++ // Allows grantee to create, overwrite, and delete any object in the bucket.+ GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`++ // Allows grantee to write the ACL for the applicable bucket.+ GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`+}++// String returns the string representation+func (s PutBucketAclInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAclInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketAclInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketAclInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.AccessControlPolicy != nil {+ if err := s.AccessControlPolicy.Validate(); err != nil {+ invalidParams.AddNested("AccessControlPolicy", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *PutBucketAclInput) SetACL(v string) *PutBucketAclInput {+ s.ACL = &v+ return s+}++// SetAccessControlPolicy sets the AccessControlPolicy field's value.+func (s *PutBucketAclInput) SetAccessControlPolicy(v *AccessControlPolicy) *PutBucketAclInput {+ s.AccessControlPolicy = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketAclInput) SetBucket(v string) *PutBucketAclInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketAclInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *PutBucketAclInput) SetGrantFullControl(v string) *PutBucketAclInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *PutBucketAclInput) SetGrantRead(v string) *PutBucketAclInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *PutBucketAclInput) SetGrantReadACP(v string) *PutBucketAclInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWrite sets the GrantWrite field's value.+func (s *PutBucketAclInput) SetGrantWrite(v string) *PutBucketAclInput {+ s.GrantWrite = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *PutBucketAclInput) SetGrantWriteACP(v string) *PutBucketAclInput {+ s.GrantWriteACP = &v+ return s+}++type PutBucketAclOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketAclOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAclOutput) GoString() string {+ return s.String()+}++type PutBucketAnalyticsConfigurationInput struct {+ _ struct{} `type:"structure" payload:"AnalyticsConfiguration"`++ // The configuration and any analyses for the analytics filter.+ //+ // AnalyticsConfiguration is a required field+ AnalyticsConfiguration *AnalyticsConfiguration `locationName:"AnalyticsConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // The name of the bucket to which an analytics configuration is stored.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The identifier used to represent an analytics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`+}++// String returns the string representation+func (s PutBucketAnalyticsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAnalyticsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketAnalyticsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketAnalyticsConfigurationInput"}+ if s.AnalyticsConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("AnalyticsConfiguration"))+ }+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.AnalyticsConfiguration != nil {+ if err := s.AnalyticsConfiguration.Validate(); err != nil {+ invalidParams.AddNested("AnalyticsConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAnalyticsConfiguration sets the AnalyticsConfiguration field's value.+func (s *PutBucketAnalyticsConfigurationInput) SetAnalyticsConfiguration(v *AnalyticsConfiguration) *PutBucketAnalyticsConfigurationInput {+ s.AnalyticsConfiguration = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketAnalyticsConfigurationInput) SetBucket(v string) *PutBucketAnalyticsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketAnalyticsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *PutBucketAnalyticsConfigurationInput) SetId(v string) *PutBucketAnalyticsConfigurationInput {+ s.Id = &v+ return s+}++type PutBucketAnalyticsConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketAnalyticsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketAnalyticsConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketCorsInput struct {+ _ struct{} `type:"structure" payload:"CORSConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // CORSConfiguration is a required field+ CORSConfiguration *CORSConfiguration `locationName:"CORSConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketCorsInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketCorsInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketCorsInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketCorsInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.CORSConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("CORSConfiguration"))+ }+ if s.CORSConfiguration != nil {+ if err := s.CORSConfiguration.Validate(); err != nil {+ invalidParams.AddNested("CORSConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketCorsInput) SetBucket(v string) *PutBucketCorsInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketCorsInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCORSConfiguration sets the CORSConfiguration field's value.+func (s *PutBucketCorsInput) SetCORSConfiguration(v *CORSConfiguration) *PutBucketCorsInput {+ s.CORSConfiguration = v+ return s+}++type PutBucketCorsOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketCorsOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketCorsOutput) GoString() string {+ return s.String()+}++type PutBucketEncryptionInput struct {+ _ struct{} `type:"structure" payload:"ServerSideEncryptionConfiguration"`++ // The name of the bucket for which the server-side encryption configuration+ // is set.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Container for server-side encryption configuration rules. Currently S3 supports+ // one rule only.+ //+ // ServerSideEncryptionConfiguration is a required field+ ServerSideEncryptionConfiguration *ServerSideEncryptionConfiguration `locationName:"ServerSideEncryptionConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketEncryptionInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketEncryptionInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketEncryptionInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketEncryptionInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.ServerSideEncryptionConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("ServerSideEncryptionConfiguration"))+ }+ if s.ServerSideEncryptionConfiguration != nil {+ if err := s.ServerSideEncryptionConfiguration.Validate(); err != nil {+ invalidParams.AddNested("ServerSideEncryptionConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketEncryptionInput) SetBucket(v string) *PutBucketEncryptionInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketEncryptionInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetServerSideEncryptionConfiguration sets the ServerSideEncryptionConfiguration field's value.+func (s *PutBucketEncryptionInput) SetServerSideEncryptionConfiguration(v *ServerSideEncryptionConfiguration) *PutBucketEncryptionInput {+ s.ServerSideEncryptionConfiguration = v+ return s+}++type PutBucketEncryptionOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketEncryptionOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketEncryptionOutput) GoString() string {+ return s.String()+}++type PutBucketInventoryConfigurationInput struct {+ _ struct{} `type:"structure" payload:"InventoryConfiguration"`++ // The name of the bucket where the inventory configuration will be stored.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the inventory configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`++ // Specifies the inventory configuration.+ //+ // InventoryConfiguration is a required field+ InventoryConfiguration *InventoryConfiguration `locationName:"InventoryConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketInventoryConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketInventoryConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketInventoryConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketInventoryConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.InventoryConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("InventoryConfiguration"))+ }+ if s.InventoryConfiguration != nil {+ if err := s.InventoryConfiguration.Validate(); err != nil {+ invalidParams.AddNested("InventoryConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketInventoryConfigurationInput) SetBucket(v string) *PutBucketInventoryConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketInventoryConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *PutBucketInventoryConfigurationInput) SetId(v string) *PutBucketInventoryConfigurationInput {+ s.Id = &v+ return s+}++// SetInventoryConfiguration sets the InventoryConfiguration field's value.+func (s *PutBucketInventoryConfigurationInput) SetInventoryConfiguration(v *InventoryConfiguration) *PutBucketInventoryConfigurationInput {+ s.InventoryConfiguration = v+ return s+}++type PutBucketInventoryConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketInventoryConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketInventoryConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketLifecycleConfigurationInput struct {+ _ struct{} `type:"structure" payload:"LifecycleConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ LifecycleConfiguration *BucketLifecycleConfiguration `locationName:"LifecycleConfiguration" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketLifecycleConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLifecycleConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketLifecycleConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketLifecycleConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.LifecycleConfiguration != nil {+ if err := s.LifecycleConfiguration.Validate(); err != nil {+ invalidParams.AddNested("LifecycleConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketLifecycleConfigurationInput) SetBucket(v string) *PutBucketLifecycleConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketLifecycleConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetLifecycleConfiguration sets the LifecycleConfiguration field's value.+func (s *PutBucketLifecycleConfigurationInput) SetLifecycleConfiguration(v *BucketLifecycleConfiguration) *PutBucketLifecycleConfigurationInput {+ s.LifecycleConfiguration = v+ return s+}++type PutBucketLifecycleConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketLifecycleConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLifecycleConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketLifecycleInput struct {+ _ struct{} `type:"structure" payload:"LifecycleConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ LifecycleConfiguration *LifecycleConfiguration `locationName:"LifecycleConfiguration" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketLifecycleInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLifecycleInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketLifecycleInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketLifecycleInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.LifecycleConfiguration != nil {+ if err := s.LifecycleConfiguration.Validate(); err != nil {+ invalidParams.AddNested("LifecycleConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketLifecycleInput) SetBucket(v string) *PutBucketLifecycleInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketLifecycleInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetLifecycleConfiguration sets the LifecycleConfiguration field's value.+func (s *PutBucketLifecycleInput) SetLifecycleConfiguration(v *LifecycleConfiguration) *PutBucketLifecycleInput {+ s.LifecycleConfiguration = v+ return s+}++type PutBucketLifecycleOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketLifecycleOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLifecycleOutput) GoString() string {+ return s.String()+}++type PutBucketLoggingInput struct {+ _ struct{} `type:"structure" payload:"BucketLoggingStatus"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // BucketLoggingStatus is a required field+ BucketLoggingStatus *BucketLoggingStatus `locationName:"BucketLoggingStatus" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketLoggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLoggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketLoggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketLoggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.BucketLoggingStatus == nil {+ invalidParams.Add(request.NewErrParamRequired("BucketLoggingStatus"))+ }+ if s.BucketLoggingStatus != nil {+ if err := s.BucketLoggingStatus.Validate(); err != nil {+ invalidParams.AddNested("BucketLoggingStatus", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketLoggingInput) SetBucket(v string) *PutBucketLoggingInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketLoggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetBucketLoggingStatus sets the BucketLoggingStatus field's value.+func (s *PutBucketLoggingInput) SetBucketLoggingStatus(v *BucketLoggingStatus) *PutBucketLoggingInput {+ s.BucketLoggingStatus = v+ return s+}++type PutBucketLoggingOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketLoggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketLoggingOutput) GoString() string {+ return s.String()+}++type PutBucketMetricsConfigurationInput struct {+ _ struct{} `type:"structure" payload:"MetricsConfiguration"`++ // The name of the bucket for which the metrics configuration is set.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The ID used to identify the metrics configuration.+ //+ // Id is a required field+ Id *string `location:"querystring" locationName:"id" type:"string" required:"true"`++ // Specifies the metrics configuration.+ //+ // MetricsConfiguration is a required field+ MetricsConfiguration *MetricsConfiguration `locationName:"MetricsConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketMetricsConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketMetricsConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketMetricsConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketMetricsConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Id == nil {+ invalidParams.Add(request.NewErrParamRequired("Id"))+ }+ if s.MetricsConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("MetricsConfiguration"))+ }+ if s.MetricsConfiguration != nil {+ if err := s.MetricsConfiguration.Validate(); err != nil {+ invalidParams.AddNested("MetricsConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketMetricsConfigurationInput) SetBucket(v string) *PutBucketMetricsConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketMetricsConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetId sets the Id field's value.+func (s *PutBucketMetricsConfigurationInput) SetId(v string) *PutBucketMetricsConfigurationInput {+ s.Id = &v+ return s+}++// SetMetricsConfiguration sets the MetricsConfiguration field's value.+func (s *PutBucketMetricsConfigurationInput) SetMetricsConfiguration(v *MetricsConfiguration) *PutBucketMetricsConfigurationInput {+ s.MetricsConfiguration = v+ return s+}++type PutBucketMetricsConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketMetricsConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketMetricsConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketNotificationConfigurationInput struct {+ _ struct{} `type:"structure" payload:"NotificationConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // A container for specifying the notification configuration of the bucket.+ // If this element is empty, notifications are turned off for the bucket.+ //+ // NotificationConfiguration is a required field+ NotificationConfiguration *NotificationConfiguration `locationName:"NotificationConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketNotificationConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketNotificationConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketNotificationConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketNotificationConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.NotificationConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("NotificationConfiguration"))+ }+ if s.NotificationConfiguration != nil {+ if err := s.NotificationConfiguration.Validate(); err != nil {+ invalidParams.AddNested("NotificationConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketNotificationConfigurationInput) SetBucket(v string) *PutBucketNotificationConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketNotificationConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetNotificationConfiguration sets the NotificationConfiguration field's value.+func (s *PutBucketNotificationConfigurationInput) SetNotificationConfiguration(v *NotificationConfiguration) *PutBucketNotificationConfigurationInput {+ s.NotificationConfiguration = v+ return s+}++type PutBucketNotificationConfigurationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketNotificationConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketNotificationConfigurationOutput) GoString() string {+ return s.String()+}++type PutBucketNotificationInput struct {+ _ struct{} `type:"structure" payload:"NotificationConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // NotificationConfiguration is a required field+ NotificationConfiguration *NotificationConfigurationDeprecated `locationName:"NotificationConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketNotificationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketNotificationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketNotificationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketNotificationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.NotificationConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("NotificationConfiguration"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketNotificationInput) SetBucket(v string) *PutBucketNotificationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketNotificationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetNotificationConfiguration sets the NotificationConfiguration field's value.+func (s *PutBucketNotificationInput) SetNotificationConfiguration(v *NotificationConfigurationDeprecated) *PutBucketNotificationInput {+ s.NotificationConfiguration = v+ return s+}++type PutBucketNotificationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketNotificationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketNotificationOutput) GoString() string {+ return s.String()+}++type PutBucketPolicyInput struct {+ _ struct{} `type:"structure" payload:"Policy"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Set this parameter to true to confirm that you want to remove your permissions+ // to change this bucket policy in the future.+ ConfirmRemoveSelfBucketAccess *bool `location:"header" locationName:"x-amz-confirm-remove-self-bucket-access" type:"boolean"`++ // The bucket policy as a JSON document.+ //+ // Policy is a required field+ Policy *string `type:"string" required:"true"`+}++// String returns the string representation+func (s PutBucketPolicyInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketPolicyInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketPolicyInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketPolicyInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Policy == nil {+ invalidParams.Add(request.NewErrParamRequired("Policy"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketPolicyInput) SetBucket(v string) *PutBucketPolicyInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketPolicyInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetConfirmRemoveSelfBucketAccess sets the ConfirmRemoveSelfBucketAccess field's value.+func (s *PutBucketPolicyInput) SetConfirmRemoveSelfBucketAccess(v bool) *PutBucketPolicyInput {+ s.ConfirmRemoveSelfBucketAccess = &v+ return s+}++// SetPolicy sets the Policy field's value.+func (s *PutBucketPolicyInput) SetPolicy(v string) *PutBucketPolicyInput {+ s.Policy = &v+ return s+}++type PutBucketPolicyOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketPolicyOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketPolicyOutput) GoString() string {+ return s.String()+}++type PutBucketReplicationInput struct {+ _ struct{} `type:"structure" payload:"ReplicationConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // A container for replication rules. You can add up to 1,000 rules. The maximum+ // size of a replication configuration is 2 MB.+ //+ // ReplicationConfiguration is a required field+ ReplicationConfiguration *ReplicationConfiguration `locationName:"ReplicationConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketReplicationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketReplicationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketReplicationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketReplicationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.ReplicationConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("ReplicationConfiguration"))+ }+ if s.ReplicationConfiguration != nil {+ if err := s.ReplicationConfiguration.Validate(); err != nil {+ invalidParams.AddNested("ReplicationConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketReplicationInput) SetBucket(v string) *PutBucketReplicationInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketReplicationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetReplicationConfiguration sets the ReplicationConfiguration field's value.+func (s *PutBucketReplicationInput) SetReplicationConfiguration(v *ReplicationConfiguration) *PutBucketReplicationInput {+ s.ReplicationConfiguration = v+ return s+}++type PutBucketReplicationOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketReplicationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketReplicationOutput) GoString() string {+ return s.String()+}++type PutBucketRequestPaymentInput struct {+ _ struct{} `type:"structure" payload:"RequestPaymentConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // RequestPaymentConfiguration is a required field+ RequestPaymentConfiguration *RequestPaymentConfiguration `locationName:"RequestPaymentConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketRequestPaymentInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketRequestPaymentInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketRequestPaymentInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketRequestPaymentInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.RequestPaymentConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("RequestPaymentConfiguration"))+ }+ if s.RequestPaymentConfiguration != nil {+ if err := s.RequestPaymentConfiguration.Validate(); err != nil {+ invalidParams.AddNested("RequestPaymentConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketRequestPaymentInput) SetBucket(v string) *PutBucketRequestPaymentInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketRequestPaymentInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetRequestPaymentConfiguration sets the RequestPaymentConfiguration field's value.+func (s *PutBucketRequestPaymentInput) SetRequestPaymentConfiguration(v *RequestPaymentConfiguration) *PutBucketRequestPaymentInput {+ s.RequestPaymentConfiguration = v+ return s+}++type PutBucketRequestPaymentOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketRequestPaymentOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketRequestPaymentOutput) GoString() string {+ return s.String()+}++type PutBucketTaggingInput struct {+ _ struct{} `type:"structure" payload:"Tagging"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Tagging is a required field+ Tagging *Tagging `locationName:"Tagging" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Tagging == nil {+ invalidParams.Add(request.NewErrParamRequired("Tagging"))+ }+ if s.Tagging != nil {+ if err := s.Tagging.Validate(); err != nil {+ invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketTaggingInput) SetBucket(v string) *PutBucketTaggingInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetTagging sets the Tagging field's value.+func (s *PutBucketTaggingInput) SetTagging(v *Tagging) *PutBucketTaggingInput {+ s.Tagging = v+ return s+}++type PutBucketTaggingOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketTaggingOutput) GoString() string {+ return s.String()+}++type PutBucketVersioningInput struct {+ _ struct{} `type:"structure" payload:"VersioningConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The concatenation of the authentication device's serial number, a space,+ // and the value that is displayed on your authentication device.+ MFA *string `location:"header" locationName:"x-amz-mfa" type:"string"`++ // VersioningConfiguration is a required field+ VersioningConfiguration *VersioningConfiguration `locationName:"VersioningConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketVersioningInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketVersioningInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketVersioningInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketVersioningInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.VersioningConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("VersioningConfiguration"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketVersioningInput) SetBucket(v string) *PutBucketVersioningInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketVersioningInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetMFA sets the MFA field's value.+func (s *PutBucketVersioningInput) SetMFA(v string) *PutBucketVersioningInput {+ s.MFA = &v+ return s+}++// SetVersioningConfiguration sets the VersioningConfiguration field's value.+func (s *PutBucketVersioningInput) SetVersioningConfiguration(v *VersioningConfiguration) *PutBucketVersioningInput {+ s.VersioningConfiguration = v+ return s+}++type PutBucketVersioningOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketVersioningOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketVersioningOutput) GoString() string {+ return s.String()+}++type PutBucketWebsiteInput struct {+ _ struct{} `type:"structure" payload:"WebsiteConfiguration"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // WebsiteConfiguration is a required field+ WebsiteConfiguration *WebsiteConfiguration `locationName:"WebsiteConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutBucketWebsiteInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketWebsiteInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutBucketWebsiteInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutBucketWebsiteInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.WebsiteConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("WebsiteConfiguration"))+ }+ if s.WebsiteConfiguration != nil {+ if err := s.WebsiteConfiguration.Validate(); err != nil {+ invalidParams.AddNested("WebsiteConfiguration", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutBucketWebsiteInput) SetBucket(v string) *PutBucketWebsiteInput {+ s.Bucket = &v+ return s+}++func (s *PutBucketWebsiteInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetWebsiteConfiguration sets the WebsiteConfiguration field's value.+func (s *PutBucketWebsiteInput) SetWebsiteConfiguration(v *WebsiteConfiguration) *PutBucketWebsiteInput {+ s.WebsiteConfiguration = v+ return s+}++type PutBucketWebsiteOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutBucketWebsiteOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutBucketWebsiteOutput) GoString() string {+ return s.String()+}++type PutObjectAclInput struct {+ _ struct{} `type:"structure" payload:"AccessControlPolicy"`++ // The canned ACL to apply to the object.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`++ AccessControlPolicy *AccessControlPolicy `locationName:"AccessControlPolicy" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Allows grantee the read, write, read ACP, and write ACP permissions on the+ // bucket.+ GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`++ // Allows grantee to list the objects in the bucket.+ GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`++ // Allows grantee to read the bucket ACL.+ GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`++ // Allows grantee to create, overwrite, and delete any object in the bucket.+ GrantWrite *string `location:"header" locationName:"x-amz-grant-write" type:"string"`++ // Allows grantee to write the ACL for the applicable bucket.+ GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // VersionId used to reference a specific version of the object.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s PutObjectAclInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectAclInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectAclInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectAclInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.AccessControlPolicy != nil {+ if err := s.AccessControlPolicy.Validate(); err != nil {+ invalidParams.AddNested("AccessControlPolicy", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *PutObjectAclInput) SetACL(v string) *PutObjectAclInput {+ s.ACL = &v+ return s+}++// SetAccessControlPolicy sets the AccessControlPolicy field's value.+func (s *PutObjectAclInput) SetAccessControlPolicy(v *AccessControlPolicy) *PutObjectAclInput {+ s.AccessControlPolicy = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectAclInput) SetBucket(v string) *PutObjectAclInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectAclInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *PutObjectAclInput) SetGrantFullControl(v string) *PutObjectAclInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *PutObjectAclInput) SetGrantRead(v string) *PutObjectAclInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *PutObjectAclInput) SetGrantReadACP(v string) *PutObjectAclInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWrite sets the GrantWrite field's value.+func (s *PutObjectAclInput) SetGrantWrite(v string) *PutObjectAclInput {+ s.GrantWrite = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *PutObjectAclInput) SetGrantWriteACP(v string) *PutObjectAclInput {+ s.GrantWriteACP = &v+ return s+}++// SetKey sets the Key field's value.+func (s *PutObjectAclInput) SetKey(v string) *PutObjectAclInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *PutObjectAclInput) SetRequestPayer(v string) *PutObjectAclInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectAclInput) SetVersionId(v string) *PutObjectAclInput {+ s.VersionId = &v+ return s+}++type PutObjectAclOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s PutObjectAclOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectAclOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *PutObjectAclOutput) SetRequestCharged(v string) *PutObjectAclOutput {+ s.RequestCharged = &v+ return s+}++type PutObjectInput struct {+ _ struct{} `type:"structure" payload:"Body"`++ // The canned ACL to apply to the object.+ ACL *string `location:"header" locationName:"x-amz-acl" type:"string" enum:"ObjectCannedACL"`++ // Object data.+ Body io.ReadSeeker `type:"blob"`++ // Name of the bucket to which the PUT operation was initiated.+ //+ // Bucket is a required field+ 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"`++ // Size of the body in bytes. This parameter is useful when the size of the+ // body cannot be determined automatically.+ ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`++ // The base64-encoded 128-bit MD5 digest of the part data.+ ContentMD5 *string `location:"header" locationName:"Content-MD5" 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"`++ // 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"`++ // Object key for which the PUT operation was initiated.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" 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"`++ // The Legal Hold status that you want to apply to the specified object.+ ObjectLockLegalHoldStatus *string `location:"header" locationName:"x-amz-object-lock-legal-hold" type:"string" enum:"ObjectLockLegalHoldStatus"`++ // The Object Lock mode that you want to apply to this object.+ ObjectLockMode *string `location:"header" locationName:"x-amz-object-lock-mode" type:"string" enum:"ObjectLockMode"`++ // The date and time when you want this object's Object Lock to expire.+ ObjectLockRetainUntilDate *time.Time `location:"header" locationName:"x-amz-object-lock-retain-until-date" type:"timestamp" timestampFormat:"iso8601"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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" sensitive:"true"`++ // 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" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // The type of storage to use for the object. Defaults to 'STANDARD'.+ StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string" enum:"StorageClass"`++ // The tag-set for the object. The tag-set must be encoded as URL Query parameters.+ // (For example, "Key1=Value1")+ Tagging *string `location:"header" locationName:"x-amz-tagging" 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"`+}++// String returns the string representation+func (s PutObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetACL sets the ACL field's value.+func (s *PutObjectInput) SetACL(v string) *PutObjectInput {+ s.ACL = &v+ return s+}++// SetBody sets the Body field's value.+func (s *PutObjectInput) SetBody(v io.ReadSeeker) *PutObjectInput {+ s.Body = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectInput) SetBucket(v string) *PutObjectInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCacheControl sets the CacheControl field's value.+func (s *PutObjectInput) SetCacheControl(v string) *PutObjectInput {+ s.CacheControl = &v+ return s+}++// SetContentDisposition sets the ContentDisposition field's value.+func (s *PutObjectInput) SetContentDisposition(v string) *PutObjectInput {+ s.ContentDisposition = &v+ return s+}++// SetContentEncoding sets the ContentEncoding field's value.+func (s *PutObjectInput) SetContentEncoding(v string) *PutObjectInput {+ s.ContentEncoding = &v+ return s+}++// SetContentLanguage sets the ContentLanguage field's value.+func (s *PutObjectInput) SetContentLanguage(v string) *PutObjectInput {+ s.ContentLanguage = &v+ return s+}++// SetContentLength sets the ContentLength field's value.+func (s *PutObjectInput) SetContentLength(v int64) *PutObjectInput {+ s.ContentLength = &v+ return s+}++// SetContentMD5 sets the ContentMD5 field's value.+func (s *PutObjectInput) SetContentMD5(v string) *PutObjectInput {+ s.ContentMD5 = &v+ return s+}++// SetContentType sets the ContentType field's value.+func (s *PutObjectInput) SetContentType(v string) *PutObjectInput {+ s.ContentType = &v+ return s+}++// SetExpires sets the Expires field's value.+func (s *PutObjectInput) SetExpires(v time.Time) *PutObjectInput {+ s.Expires = &v+ return s+}++// SetGrantFullControl sets the GrantFullControl field's value.+func (s *PutObjectInput) SetGrantFullControl(v string) *PutObjectInput {+ s.GrantFullControl = &v+ return s+}++// SetGrantRead sets the GrantRead field's value.+func (s *PutObjectInput) SetGrantRead(v string) *PutObjectInput {+ s.GrantRead = &v+ return s+}++// SetGrantReadACP sets the GrantReadACP field's value.+func (s *PutObjectInput) SetGrantReadACP(v string) *PutObjectInput {+ s.GrantReadACP = &v+ return s+}++// SetGrantWriteACP sets the GrantWriteACP field's value.+func (s *PutObjectInput) SetGrantWriteACP(v string) *PutObjectInput {+ s.GrantWriteACP = &v+ return s+}++// SetKey sets the Key field's value.+func (s *PutObjectInput) SetKey(v string) *PutObjectInput {+ s.Key = &v+ return s+}++// SetMetadata sets the Metadata field's value.+func (s *PutObjectInput) SetMetadata(v map[string]*string) *PutObjectInput {+ s.Metadata = v+ return s+}++// SetObjectLockLegalHoldStatus sets the ObjectLockLegalHoldStatus field's value.+func (s *PutObjectInput) SetObjectLockLegalHoldStatus(v string) *PutObjectInput {+ s.ObjectLockLegalHoldStatus = &v+ return s+}++// SetObjectLockMode sets the ObjectLockMode field's value.+func (s *PutObjectInput) SetObjectLockMode(v string) *PutObjectInput {+ s.ObjectLockMode = &v+ return s+}++// SetObjectLockRetainUntilDate sets the ObjectLockRetainUntilDate field's value.+func (s *PutObjectInput) SetObjectLockRetainUntilDate(v time.Time) *PutObjectInput {+ s.ObjectLockRetainUntilDate = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *PutObjectInput) SetRequestPayer(v string) *PutObjectInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *PutObjectInput) SetSSECustomerAlgorithm(v string) *PutObjectInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *PutObjectInput) SetSSECustomerKey(v string) *PutObjectInput {+ s.SSECustomerKey = &v+ return s+}++func (s *PutObjectInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *PutObjectInput) SetSSECustomerKeyMD5(v string) *PutObjectInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *PutObjectInput) SetSSEKMSKeyId(v string) *PutObjectInput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *PutObjectInput) SetServerSideEncryption(v string) *PutObjectInput {+ s.ServerSideEncryption = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *PutObjectInput) SetStorageClass(v string) *PutObjectInput {+ s.StorageClass = &v+ return s+}++// SetTagging sets the Tagging field's value.+func (s *PutObjectInput) SetTagging(v string) *PutObjectInput {+ s.Tagging = &v+ return s+}++// SetWebsiteRedirectLocation sets the WebsiteRedirectLocation field's value.+func (s *PutObjectInput) SetWebsiteRedirectLocation(v string) *PutObjectInput {+ s.WebsiteRedirectLocation = &v+ return s+}++type PutObjectLegalHoldInput struct {+ _ struct{} `type:"structure" payload:"LegalHold"`++ // The bucket containing the object that you want to place a Legal Hold on.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The key name for the object that you want to place a Legal Hold on.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Container element for the Legal Hold configuration you want to apply to the+ // specified object.+ LegalHold *ObjectLockLegalHold `locationName:"LegalHold" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // 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" enum:"RequestPayer"`++ // The version ID of the object that you want to place a Legal Hold on.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s PutObjectLegalHoldInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectLegalHoldInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectLegalHoldInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectLegalHoldInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectLegalHoldInput) SetBucket(v string) *PutObjectLegalHoldInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectLegalHoldInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *PutObjectLegalHoldInput) SetKey(v string) *PutObjectLegalHoldInput {+ s.Key = &v+ return s+}++// SetLegalHold sets the LegalHold field's value.+func (s *PutObjectLegalHoldInput) SetLegalHold(v *ObjectLockLegalHold) *PutObjectLegalHoldInput {+ s.LegalHold = v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *PutObjectLegalHoldInput) SetRequestPayer(v string) *PutObjectLegalHoldInput {+ s.RequestPayer = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectLegalHoldInput) SetVersionId(v string) *PutObjectLegalHoldInput {+ s.VersionId = &v+ return s+}++type PutObjectLegalHoldOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s PutObjectLegalHoldOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectLegalHoldOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *PutObjectLegalHoldOutput) SetRequestCharged(v string) *PutObjectLegalHoldOutput {+ s.RequestCharged = &v+ return s+}++type PutObjectLockConfigurationInput struct {+ _ struct{} `type:"structure" payload:"ObjectLockConfiguration"`++ // The bucket whose Object Lock configuration you want to create or replace.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The Object Lock configuration that you want to apply to the specified bucket.+ ObjectLockConfiguration *ObjectLockConfiguration `locationName:"ObjectLockConfiguration" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // 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" enum:"RequestPayer"`++ Token *string `location:"header" locationName:"x-amz-bucket-object-lock-token" type:"string"`+}++// String returns the string representation+func (s PutObjectLockConfigurationInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectLockConfigurationInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectLockConfigurationInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectLockConfigurationInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectLockConfigurationInput) SetBucket(v string) *PutObjectLockConfigurationInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectLockConfigurationInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetObjectLockConfiguration sets the ObjectLockConfiguration field's value.+func (s *PutObjectLockConfigurationInput) SetObjectLockConfiguration(v *ObjectLockConfiguration) *PutObjectLockConfigurationInput {+ s.ObjectLockConfiguration = v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *PutObjectLockConfigurationInput) SetRequestPayer(v string) *PutObjectLockConfigurationInput {+ s.RequestPayer = &v+ return s+}++// SetToken sets the Token field's value.+func (s *PutObjectLockConfigurationInput) SetToken(v string) *PutObjectLockConfigurationInput {+ s.Token = &v+ return s+}++type PutObjectLockConfigurationOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s PutObjectLockConfigurationOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectLockConfigurationOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *PutObjectLockConfigurationOutput) SetRequestCharged(v string) *PutObjectLockConfigurationOutput {+ s.RequestCharged = &v+ return s+}++type PutObjectOutput struct {+ _ struct{} `type:"structure"`++ // Entity tag for the uploaded object.+ ETag *string `location:"header" locationName:"ETag" type:"string"`++ // If the object expiration is configured, this will contain the expiration+ // date (expiry-date) and rule ID (rule-id). The value of rule-id is URL encoded.+ Expiration *string `location:"header" locationName:"x-amz-expiration" type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`++ // Version of the object.+ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s PutObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectOutput) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *PutObjectOutput) SetETag(v string) *PutObjectOutput {+ s.ETag = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *PutObjectOutput) SetExpiration(v string) *PutObjectOutput {+ s.Expiration = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *PutObjectOutput) SetRequestCharged(v string) *PutObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *PutObjectOutput) SetSSECustomerAlgorithm(v string) *PutObjectOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *PutObjectOutput) SetSSECustomerKeyMD5(v string) *PutObjectOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *PutObjectOutput) SetSSEKMSKeyId(v string) *PutObjectOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *PutObjectOutput) SetServerSideEncryption(v string) *PutObjectOutput {+ s.ServerSideEncryption = &v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectOutput) SetVersionId(v string) *PutObjectOutput {+ s.VersionId = &v+ return s+}++type PutObjectRetentionInput struct {+ _ struct{} `type:"structure" payload:"Retention"`++ // The bucket that contains the object you want to apply this Object Retention+ // configuration to.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Indicates whether this operation should bypass Governance-mode restrictions.j+ BypassGovernanceRetention *bool `location:"header" locationName:"x-amz-bypass-governance-retention" type:"boolean"`++ // The key name for the object that you want to apply this Object Retention+ // configuration to.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // The container element for the Object Retention configuration.+ Retention *ObjectLockRetention `locationName:"Retention" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // The version ID for the object that you want to apply this Object Retention+ // configuration to.+ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s PutObjectRetentionInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectRetentionInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectRetentionInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectRetentionInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectRetentionInput) SetBucket(v string) *PutObjectRetentionInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectRetentionInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetBypassGovernanceRetention sets the BypassGovernanceRetention field's value.+func (s *PutObjectRetentionInput) SetBypassGovernanceRetention(v bool) *PutObjectRetentionInput {+ s.BypassGovernanceRetention = &v+ return s+}++// SetKey sets the Key field's value.+func (s *PutObjectRetentionInput) SetKey(v string) *PutObjectRetentionInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *PutObjectRetentionInput) SetRequestPayer(v string) *PutObjectRetentionInput {+ s.RequestPayer = &v+ return s+}++// SetRetention sets the Retention field's value.+func (s *PutObjectRetentionInput) SetRetention(v *ObjectLockRetention) *PutObjectRetentionInput {+ s.Retention = v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectRetentionInput) SetVersionId(v string) *PutObjectRetentionInput {+ s.VersionId = &v+ return s+}++type PutObjectRetentionOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`+}++// String returns the string representation+func (s PutObjectRetentionOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectRetentionOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *PutObjectRetentionOutput) SetRequestCharged(v string) *PutObjectRetentionOutput {+ s.RequestCharged = &v+ return s+}++type PutObjectTaggingInput struct {+ _ struct{} `type:"structure" payload:"Tagging"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Tagging is a required field+ Tagging *Tagging `locationName:"Tagging" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s PutObjectTaggingInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectTaggingInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutObjectTaggingInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutObjectTaggingInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.Tagging == nil {+ invalidParams.Add(request.NewErrParamRequired("Tagging"))+ }+ if s.Tagging != nil {+ if err := s.Tagging.Validate(); err != nil {+ invalidParams.AddNested("Tagging", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutObjectTaggingInput) SetBucket(v string) *PutObjectTaggingInput {+ s.Bucket = &v+ return s+}++func (s *PutObjectTaggingInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *PutObjectTaggingInput) SetKey(v string) *PutObjectTaggingInput {+ s.Key = &v+ return s+}++// SetTagging sets the Tagging field's value.+func (s *PutObjectTaggingInput) SetTagging(v *Tagging) *PutObjectTaggingInput {+ s.Tagging = v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectTaggingInput) SetVersionId(v string) *PutObjectTaggingInput {+ s.VersionId = &v+ return s+}++type PutObjectTaggingOutput struct {+ _ struct{} `type:"structure"`++ VersionId *string `location:"header" locationName:"x-amz-version-id" type:"string"`+}++// String returns the string representation+func (s PutObjectTaggingOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutObjectTaggingOutput) GoString() string {+ return s.String()+}++// SetVersionId sets the VersionId field's value.+func (s *PutObjectTaggingOutput) SetVersionId(v string) *PutObjectTaggingOutput {+ s.VersionId = &v+ return s+}++type PutPublicAccessBlockInput struct {+ _ struct{} `type:"structure" payload:"PublicAccessBlockConfiguration"`++ // The name of the Amazon S3 bucket whose PublicAccessBlock configuration you+ // want to set.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The PublicAccessBlock configuration that you want to apply to this Amazon+ // S3 bucket. You can enable the configuration options in any combination. For+ // more information about when Amazon S3 considers a bucket or object public,+ // see The Meaning of "Public" (https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status)+ // in the Amazon Simple Storage Service Developer Guide.+ //+ // PublicAccessBlockConfiguration is a required field+ PublicAccessBlockConfiguration *PublicAccessBlockConfiguration `locationName:"PublicAccessBlockConfiguration" type:"structure" required:"true" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`+}++// String returns the string representation+func (s PutPublicAccessBlockInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutPublicAccessBlockInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *PutPublicAccessBlockInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "PutPublicAccessBlockInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.PublicAccessBlockConfiguration == nil {+ invalidParams.Add(request.NewErrParamRequired("PublicAccessBlockConfiguration"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *PutPublicAccessBlockInput) SetBucket(v string) *PutPublicAccessBlockInput {+ s.Bucket = &v+ return s+}++func (s *PutPublicAccessBlockInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetPublicAccessBlockConfiguration sets the PublicAccessBlockConfiguration field's value.+func (s *PutPublicAccessBlockInput) SetPublicAccessBlockConfiguration(v *PublicAccessBlockConfiguration) *PutPublicAccessBlockInput {+ s.PublicAccessBlockConfiguration = v+ return s+}++type PutPublicAccessBlockOutput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s PutPublicAccessBlockOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s PutPublicAccessBlockOutput) GoString() string {+ return s.String()+}++// A container for specifying the configuration for publication of messages+// to an Amazon Simple Queue Service (Amazon SQS) queue.when Amazon S3 detects+// specified events.+type QueueConfiguration struct {+ _ struct{} `type:"structure"`++ // Events is a required field+ Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`++ // A container for object key name filtering rules. For information about key+ // name filtering, see Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)+ // in the Amazon Simple Storage Service Developer Guide.+ Filter *NotificationConfigurationFilter `type:"structure"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ // The Amazon Resource Name (ARN) of the Amazon SQS queue to which Amazon S3+ // will publish a message when it detects events of the specified type.+ //+ // QueueArn is a required field+ QueueArn *string `locationName:"Queue" type:"string" required:"true"`+}++// String returns the string representation+func (s QueueConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s QueueConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *QueueConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "QueueConfiguration"}+ if s.Events == nil {+ invalidParams.Add(request.NewErrParamRequired("Events"))+ }+ if s.QueueArn == nil {+ invalidParams.Add(request.NewErrParamRequired("QueueArn"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetEvents sets the Events field's value.+func (s *QueueConfiguration) SetEvents(v []*string) *QueueConfiguration {+ s.Events = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *QueueConfiguration) SetFilter(v *NotificationConfigurationFilter) *QueueConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *QueueConfiguration) SetId(v string) *QueueConfiguration {+ s.Id = &v+ return s+}++// SetQueueArn sets the QueueArn field's value.+func (s *QueueConfiguration) SetQueueArn(v string) *QueueConfiguration {+ s.QueueArn = &v+ return s+}++type QueueConfigurationDeprecated struct {+ _ struct{} `type:"structure"`++ // The bucket event for which to send notifications.+ //+ // Deprecated: Event has been deprecated+ Event *string `deprecated:"true" type:"string" enum:"Event"`++ Events []*string `locationName:"Event" type:"list" flattened:"true"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ Queue *string `type:"string"`+}++// String returns the string representation+func (s QueueConfigurationDeprecated) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s QueueConfigurationDeprecated) GoString() string {+ return s.String()+}++// SetEvent sets the Event field's value.+func (s *QueueConfigurationDeprecated) SetEvent(v string) *QueueConfigurationDeprecated {+ s.Event = &v+ return s+}++// SetEvents sets the Events field's value.+func (s *QueueConfigurationDeprecated) SetEvents(v []*string) *QueueConfigurationDeprecated {+ s.Events = v+ return s+}++// SetId sets the Id field's value.+func (s *QueueConfigurationDeprecated) SetId(v string) *QueueConfigurationDeprecated {+ s.Id = &v+ return s+}++// SetQueue sets the Queue field's value.+func (s *QueueConfigurationDeprecated) SetQueue(v string) *QueueConfigurationDeprecated {+ s.Queue = &v+ return s+}++type RecordsEvent struct {+ _ struct{} `locationName:"RecordsEvent" type:"structure" payload:"Payload"`++ // The byte array of partial, one or more result records.+ //+ // Payload is automatically base64 encoded/decoded by the SDK.+ Payload []byte `type:"blob"`+}++// String returns the string representation+func (s RecordsEvent) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RecordsEvent) GoString() string {+ return s.String()+}++// SetPayload sets the Payload field's value.+func (s *RecordsEvent) SetPayload(v []byte) *RecordsEvent {+ s.Payload = v+ return s+}++// The RecordsEvent is and event in the SelectObjectContentEventStream group of events.+func (s *RecordsEvent) eventSelectObjectContentEventStream() {}++// UnmarshalEvent unmarshals the EventStream Message into the RecordsEvent value.+// This method is only used internally within the SDK's EventStream handling.+func (s *RecordsEvent) UnmarshalEvent(+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ msg eventstream.Message,+) error {+ s.Payload = make([]byte, len(msg.Payload))+ copy(s.Payload, msg.Payload)+ return nil+}++type Redirect struct {+ _ struct{} `type:"structure"`++ // The host name to use in the redirect request.+ HostName *string `type:"string"`++ // The HTTP redirect code to use on the response. Not required if one of the+ // siblings is present.+ HttpRedirectCode *string `type:"string"`++ // Protocol to use (http, https) when redirecting requests. The default is the+ // protocol that is used in the original request.+ Protocol *string `type:"string" enum:"Protocol"`++ // The object key prefix to use in the redirect request. For example, to redirect+ // requests for all pages with prefix docs/ (objects in the docs/ folder) to+ // documents/, you can set a condition block with KeyPrefixEquals set to docs/+ // and in the Redirect set ReplaceKeyPrefixWith to /documents. Not required+ // if one of the siblings is present. Can be present only if ReplaceKeyWith+ // is not provided.+ ReplaceKeyPrefixWith *string `type:"string"`++ // The specific object key to use in the redirect request. For example, redirect+ // request to error.html. Not required if one of the sibling is present. Can+ // be present only if ReplaceKeyPrefixWith is not provided.+ ReplaceKeyWith *string `type:"string"`+}++// String returns the string representation+func (s Redirect) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Redirect) GoString() string {+ return s.String()+}++// SetHostName sets the HostName field's value.+func (s *Redirect) SetHostName(v string) *Redirect {+ s.HostName = &v+ return s+}++// SetHttpRedirectCode sets the HttpRedirectCode field's value.+func (s *Redirect) SetHttpRedirectCode(v string) *Redirect {+ s.HttpRedirectCode = &v+ return s+}++// SetProtocol sets the Protocol field's value.+func (s *Redirect) SetProtocol(v string) *Redirect {+ s.Protocol = &v+ return s+}++// SetReplaceKeyPrefixWith sets the ReplaceKeyPrefixWith field's value.+func (s *Redirect) SetReplaceKeyPrefixWith(v string) *Redirect {+ s.ReplaceKeyPrefixWith = &v+ return s+}++// SetReplaceKeyWith sets the ReplaceKeyWith field's value.+func (s *Redirect) SetReplaceKeyWith(v string) *Redirect {+ s.ReplaceKeyWith = &v+ return s+}++type RedirectAllRequestsTo struct {+ _ struct{} `type:"structure"`++ // Name of the host where requests will be redirected.+ //+ // HostName is a required field+ HostName *string `type:"string" required:"true"`++ // Protocol to use (http, https) when redirecting requests. The default is the+ // protocol that is used in the original request.+ Protocol *string `type:"string" enum:"Protocol"`+}++// String returns the string representation+func (s RedirectAllRequestsTo) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RedirectAllRequestsTo) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *RedirectAllRequestsTo) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "RedirectAllRequestsTo"}+ if s.HostName == nil {+ invalidParams.Add(request.NewErrParamRequired("HostName"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetHostName sets the HostName field's value.+func (s *RedirectAllRequestsTo) SetHostName(v string) *RedirectAllRequestsTo {+ s.HostName = &v+ return s+}++// SetProtocol sets the Protocol field's value.+func (s *RedirectAllRequestsTo) SetProtocol(v string) *RedirectAllRequestsTo {+ s.Protocol = &v+ return s+}++// A container for replication rules. You can add up to 1,000 rules. The maximum+// size of a replication configuration is 2 MB.+type ReplicationConfiguration struct {+ _ struct{} `type:"structure"`++ // The Amazon Resource Name (ARN) of the AWS Identity and Access Management+ // (IAM) role that Amazon S3 can assume when replicating the objects.+ //+ // Role is a required field+ Role *string `type:"string" required:"true"`++ // A container for one or more replication rules. A replication configuration+ // must have at least one rule and can contain a maximum of 1,000 rules.+ //+ // Rules is a required field+ Rules []*ReplicationRule `locationName:"Rule" type:"list" flattened:"true" required:"true"`+}++// String returns the string representation+func (s ReplicationConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ReplicationConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ReplicationConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ReplicationConfiguration"}+ if s.Role == nil {+ invalidParams.Add(request.NewErrParamRequired("Role"))+ }+ if s.Rules == nil {+ invalidParams.Add(request.NewErrParamRequired("Rules"))+ }+ if s.Rules != nil {+ for i, v := range s.Rules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetRole sets the Role field's value.+func (s *ReplicationConfiguration) SetRole(v string) *ReplicationConfiguration {+ s.Role = &v+ return s+}++// SetRules sets the Rules field's value.+func (s *ReplicationConfiguration) SetRules(v []*ReplicationRule) *ReplicationConfiguration {+ s.Rules = v+ return s+}++// A container for information about a specific replication rule.+type ReplicationRule struct {+ _ struct{} `type:"structure"`++ // Specifies whether Amazon S3 should replicate delete makers.+ DeleteMarkerReplication *DeleteMarkerReplication `type:"structure"`++ // A container for information about the replication destination.+ //+ // Destination is a required field+ Destination *Destination `type:"structure" required:"true"`++ // A filter that identifies the subset of objects to which the replication rule+ // applies. A Filter must specify exactly one Prefix, Tag, or an And child element.+ Filter *ReplicationRuleFilter `type:"structure"`++ // A unique identifier for the rule. The maximum value is 255 characters.+ ID *string `type:"string"`++ // An object keyname prefix that identifies the object or objects to which the+ // rule applies. The maximum prefix length is 1,024 characters.+ //+ // Deprecated: Prefix has been deprecated+ Prefix *string `deprecated:"true" type:"string"`++ // The priority associated with the rule. If you specify multiple rules in a+ // replication configuration, Amazon S3 prioritizes the rules to prevent conflicts+ // when filtering. If two or more rules identify the same object based on a+ // specified filter, the rule with higher priority takes precedence. For example:+ //+ // * Same object quality prefix based filter criteria If prefixes you specified+ // in multiple rules overlap+ //+ // * Same object qualify tag based filter criteria specified in multiple+ // rules+ //+ // For more information, see Cross-Region Replication (CRR) ( https://docs.aws.amazon.com/AmazonS3/latest/dev/crr.html)+ // in the Amazon S3 Developer Guide.+ Priority *int64 `type:"integer"`++ // A container that describes additional filters for identifying the source+ // objects that you want to replicate. You can choose to enable or disable the+ // replication of these objects. Currently, Amazon S3 supports only the filter+ // that you can specify for objects created with server-side encryption using+ // an AWS KMS-Managed Key (SSE-KMS).+ //+ // If you want Amazon S3 to replicate objects created with server-side encryption+ // using AWS KMS-Managed Keys.+ SourceSelectionCriteria *SourceSelectionCriteria `type:"structure"`++ // If status isn't enabled, the rule is ignored.+ //+ // Status is a required field+ Status *string `type:"string" required:"true" enum:"ReplicationRuleStatus"`+}++// String returns the string representation+func (s ReplicationRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ReplicationRule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ReplicationRule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ReplicationRule"}+ if s.Destination == nil {+ invalidParams.Add(request.NewErrParamRequired("Destination"))+ }+ if s.Status == nil {+ invalidParams.Add(request.NewErrParamRequired("Status"))+ }+ if s.Destination != nil {+ if err := s.Destination.Validate(); err != nil {+ invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))+ }+ }+ if s.Filter != nil {+ if err := s.Filter.Validate(); err != nil {+ invalidParams.AddNested("Filter", err.(request.ErrInvalidParams))+ }+ }+ if s.SourceSelectionCriteria != nil {+ if err := s.SourceSelectionCriteria.Validate(); err != nil {+ invalidParams.AddNested("SourceSelectionCriteria", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDeleteMarkerReplication sets the DeleteMarkerReplication field's value.+func (s *ReplicationRule) SetDeleteMarkerReplication(v *DeleteMarkerReplication) *ReplicationRule {+ s.DeleteMarkerReplication = v+ return s+}++// SetDestination sets the Destination field's value.+func (s *ReplicationRule) SetDestination(v *Destination) *ReplicationRule {+ s.Destination = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *ReplicationRule) SetFilter(v *ReplicationRuleFilter) *ReplicationRule {+ s.Filter = v+ return s+}++// SetID sets the ID field's value.+func (s *ReplicationRule) SetID(v string) *ReplicationRule {+ s.ID = &v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ReplicationRule) SetPrefix(v string) *ReplicationRule {+ s.Prefix = &v+ return s+}++// SetPriority sets the Priority field's value.+func (s *ReplicationRule) SetPriority(v int64) *ReplicationRule {+ s.Priority = &v+ return s+}++// SetSourceSelectionCriteria sets the SourceSelectionCriteria field's value.+func (s *ReplicationRule) SetSourceSelectionCriteria(v *SourceSelectionCriteria) *ReplicationRule {+ s.SourceSelectionCriteria = v+ return s+}++// SetStatus sets the Status field's value.+func (s *ReplicationRule) SetStatus(v string) *ReplicationRule {+ s.Status = &v+ return s+}++type ReplicationRuleAndOperator struct {+ _ struct{} `type:"structure"`++ Prefix *string `type:"string"`++ Tags []*Tag `locationName:"Tag" locationNameList:"Tag" type:"list" flattened:"true"`+}++// String returns the string representation+func (s ReplicationRuleAndOperator) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ReplicationRuleAndOperator) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ReplicationRuleAndOperator) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ReplicationRuleAndOperator"}+ if s.Tags != nil {+ for i, v := range s.Tags {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPrefix sets the Prefix field's value.+func (s *ReplicationRuleAndOperator) SetPrefix(v string) *ReplicationRuleAndOperator {+ s.Prefix = &v+ return s+}++// SetTags sets the Tags field's value.+func (s *ReplicationRuleAndOperator) SetTags(v []*Tag) *ReplicationRuleAndOperator {+ s.Tags = v+ return s+}++// A filter that identifies the subset of objects to which the replication rule+// applies. A Filter must specify exactly one Prefix, Tag, or an And child element.+type ReplicationRuleFilter struct {+ _ struct{} `type:"structure"`++ // A container for specifying rule filters. The filters determine the subset+ // of objects to which the rule applies. This element is required only if you+ // specify more than one filter. For example:+ //+ // * If you specify both a Prefix and a Tag filter, wrap these filters in+ // an And tag.+ //+ // * If you specify a filter based on multiple tags, wrap the Tag elements+ // in an And tag.+ And *ReplicationRuleAndOperator `type:"structure"`++ // An object keyname prefix that identifies the subset of objects to which the+ // rule applies.+ Prefix *string `type:"string"`++ // A container for specifying a tag key and value.+ //+ // The rule applies only to objects that have the tag in their tag set.+ Tag *Tag `type:"structure"`+}++// String returns the string representation+func (s ReplicationRuleFilter) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ReplicationRuleFilter) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ReplicationRuleFilter) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ReplicationRuleFilter"}+ if s.And != nil {+ if err := s.And.Validate(); err != nil {+ invalidParams.AddNested("And", err.(request.ErrInvalidParams))+ }+ }+ if s.Tag != nil {+ if err := s.Tag.Validate(); err != nil {+ invalidParams.AddNested("Tag", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAnd sets the And field's value.+func (s *ReplicationRuleFilter) SetAnd(v *ReplicationRuleAndOperator) *ReplicationRuleFilter {+ s.And = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *ReplicationRuleFilter) SetPrefix(v string) *ReplicationRuleFilter {+ s.Prefix = &v+ return s+}++// SetTag sets the Tag field's value.+func (s *ReplicationRuleFilter) SetTag(v *Tag) *ReplicationRuleFilter {+ s.Tag = v+ return s+}++type RequestPaymentConfiguration struct {+ _ struct{} `type:"structure"`++ // Specifies who pays for the download and request fees.+ //+ // Payer is a required field+ Payer *string `type:"string" required:"true" enum:"Payer"`+}++// String returns the string representation+func (s RequestPaymentConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RequestPaymentConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *RequestPaymentConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "RequestPaymentConfiguration"}+ if s.Payer == nil {+ invalidParams.Add(request.NewErrParamRequired("Payer"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetPayer sets the Payer field's value.+func (s *RequestPaymentConfiguration) SetPayer(v string) *RequestPaymentConfiguration {+ s.Payer = &v+ return s+}++type RequestProgress struct {+ _ struct{} `type:"structure"`++ // Specifies whether periodic QueryProgress frames should be sent. Valid values:+ // TRUE, FALSE. Default value: FALSE.+ Enabled *bool `type:"boolean"`+}++// String returns the string representation+func (s RequestProgress) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RequestProgress) GoString() string {+ return s.String()+}++// SetEnabled sets the Enabled field's value.+func (s *RequestProgress) SetEnabled(v bool) *RequestProgress {+ s.Enabled = &v+ return s+}++type RestoreObjectInput struct {+ _ struct{} `type:"structure" payload:"RestoreRequest"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // 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" enum:"RequestPayer"`++ // Container for restore job parameters.+ RestoreRequest *RestoreRequest `locationName:"RestoreRequest" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ VersionId *string `location:"querystring" locationName:"versionId" type:"string"`+}++// String returns the string representation+func (s RestoreObjectInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RestoreObjectInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *RestoreObjectInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "RestoreObjectInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.RestoreRequest != nil {+ if err := s.RestoreRequest.Validate(); err != nil {+ invalidParams.AddNested("RestoreRequest", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *RestoreObjectInput) SetBucket(v string) *RestoreObjectInput {+ s.Bucket = &v+ return s+}++func (s *RestoreObjectInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetKey sets the Key field's value.+func (s *RestoreObjectInput) SetKey(v string) *RestoreObjectInput {+ s.Key = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *RestoreObjectInput) SetRequestPayer(v string) *RestoreObjectInput {+ s.RequestPayer = &v+ return s+}++// SetRestoreRequest sets the RestoreRequest field's value.+func (s *RestoreObjectInput) SetRestoreRequest(v *RestoreRequest) *RestoreObjectInput {+ s.RestoreRequest = v+ return s+}++// SetVersionId sets the VersionId field's value.+func (s *RestoreObjectInput) SetVersionId(v string) *RestoreObjectInput {+ s.VersionId = &v+ return s+}++type RestoreObjectOutput struct {+ _ struct{} `type:"structure"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // Indicates the path in the provided S3 output location where Select results+ // will be restored to.+ RestoreOutputPath *string `location:"header" locationName:"x-amz-restore-output-path" type:"string"`+}++// String returns the string representation+func (s RestoreObjectOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RestoreObjectOutput) GoString() string {+ return s.String()+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *RestoreObjectOutput) SetRequestCharged(v string) *RestoreObjectOutput {+ s.RequestCharged = &v+ return s+}++// SetRestoreOutputPath sets the RestoreOutputPath field's value.+func (s *RestoreObjectOutput) SetRestoreOutputPath(v string) *RestoreObjectOutput {+ s.RestoreOutputPath = &v+ return s+}++// Container for restore job parameters.+type RestoreRequest struct {+ _ struct{} `type:"structure"`++ // Lifetime of the active copy in days. Do not use with restores that specify+ // OutputLocation.+ Days *int64 `type:"integer"`++ // The optional description for the job.+ Description *string `type:"string"`++ // Glacier related parameters pertaining to this job. Do not use with restores+ // that specify OutputLocation.+ GlacierJobParameters *GlacierJobParameters `type:"structure"`++ // Describes the location where the restore job's output is stored.+ OutputLocation *OutputLocation `type:"structure"`++ // Describes the parameters for Select job types.+ SelectParameters *SelectParameters `type:"structure"`++ // Glacier retrieval tier at which the restore will be processed.+ Tier *string `type:"string" enum:"Tier"`++ // Type of restore request.+ Type *string `type:"string" enum:"RestoreRequestType"`+}++// String returns the string representation+func (s RestoreRequest) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RestoreRequest) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *RestoreRequest) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "RestoreRequest"}+ if s.GlacierJobParameters != nil {+ if err := s.GlacierJobParameters.Validate(); err != nil {+ invalidParams.AddNested("GlacierJobParameters", err.(request.ErrInvalidParams))+ }+ }+ if s.OutputLocation != nil {+ if err := s.OutputLocation.Validate(); err != nil {+ invalidParams.AddNested("OutputLocation", err.(request.ErrInvalidParams))+ }+ }+ if s.SelectParameters != nil {+ if err := s.SelectParameters.Validate(); err != nil {+ invalidParams.AddNested("SelectParameters", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDays sets the Days field's value.+func (s *RestoreRequest) SetDays(v int64) *RestoreRequest {+ s.Days = &v+ return s+}++// SetDescription sets the Description field's value.+func (s *RestoreRequest) SetDescription(v string) *RestoreRequest {+ s.Description = &v+ return s+}++// SetGlacierJobParameters sets the GlacierJobParameters field's value.+func (s *RestoreRequest) SetGlacierJobParameters(v *GlacierJobParameters) *RestoreRequest {+ s.GlacierJobParameters = v+ return s+}++// SetOutputLocation sets the OutputLocation field's value.+func (s *RestoreRequest) SetOutputLocation(v *OutputLocation) *RestoreRequest {+ s.OutputLocation = v+ return s+}++// SetSelectParameters sets the SelectParameters field's value.+func (s *RestoreRequest) SetSelectParameters(v *SelectParameters) *RestoreRequest {+ s.SelectParameters = v+ return s+}++// SetTier sets the Tier field's value.+func (s *RestoreRequest) SetTier(v string) *RestoreRequest {+ s.Tier = &v+ return s+}++// SetType sets the Type field's value.+func (s *RestoreRequest) SetType(v string) *RestoreRequest {+ s.Type = &v+ return s+}++type RoutingRule struct {+ _ struct{} `type:"structure"`++ // A container for describing a condition that must be met for the specified+ // redirect to apply. For example, 1. If request is for pages in the /docs folder,+ // redirect to the /documents folder. 2. If request results in HTTP error 4xx,+ // redirect request to another host where you might process the error.+ Condition *Condition `type:"structure"`++ // Container for redirect information. You can redirect requests to another+ // host, to another page, or with another protocol. In the event of an error,+ // you can specify a different error code to return.+ //+ // Redirect is a required field+ Redirect *Redirect `type:"structure" required:"true"`+}++// String returns the string representation+func (s RoutingRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s RoutingRule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *RoutingRule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "RoutingRule"}+ if s.Redirect == nil {+ invalidParams.Add(request.NewErrParamRequired("Redirect"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetCondition sets the Condition field's value.+func (s *RoutingRule) SetCondition(v *Condition) *RoutingRule {+ s.Condition = v+ return s+}++// SetRedirect sets the Redirect field's value.+func (s *RoutingRule) SetRedirect(v *Redirect) *RoutingRule {+ s.Redirect = v+ return s+}++type Rule struct {+ _ struct{} `type:"structure"`++ // Specifies the days since the initiation of an Incomplete Multipart Upload+ // that Lifecycle will wait before permanently removing all parts of the upload.+ AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload `type:"structure"`++ Expiration *LifecycleExpiration `type:"structure"`++ // Unique identifier for the rule. The value cannot be longer than 255 characters.+ ID *string `type:"string"`++ // Specifies when noncurrent object versions expire. Upon expiration, Amazon+ // S3 permanently deletes the noncurrent object versions. You set this lifecycle+ // configuration action on a bucket that has versioning enabled (or suspended)+ // to request that Amazon S3 delete noncurrent object versions at a specific+ // period in the object's lifetime.+ NoncurrentVersionExpiration *NoncurrentVersionExpiration `type:"structure"`++ // Container for the transition rule that describes when noncurrent objects+ // transition to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING or GLACIER+ // storage class. If your bucket is versioning-enabled (or versioning is suspended),+ // you can set this action to request that Amazon S3 transition noncurrent object+ // versions to the STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING or GLACIER storage+ // class at a specific period in the object's lifetime.+ NoncurrentVersionTransition *NoncurrentVersionTransition `type:"structure"`++ // Prefix identifying one or more objects to which the rule applies.+ //+ // Prefix is a required field+ Prefix *string `type:"string" required:"true"`++ // If 'Enabled', the rule is currently being applied. If 'Disabled', the rule+ // is not currently being applied.+ //+ // Status is a required field+ Status *string `type:"string" required:"true" enum:"ExpirationStatus"`++ Transition *Transition `type:"structure"`+}++// String returns the string representation+func (s Rule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Rule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Rule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Rule"}+ if s.Prefix == nil {+ invalidParams.Add(request.NewErrParamRequired("Prefix"))+ }+ if s.Status == nil {+ invalidParams.Add(request.NewErrParamRequired("Status"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetAbortIncompleteMultipartUpload sets the AbortIncompleteMultipartUpload field's value.+func (s *Rule) SetAbortIncompleteMultipartUpload(v *AbortIncompleteMultipartUpload) *Rule {+ s.AbortIncompleteMultipartUpload = v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *Rule) SetExpiration(v *LifecycleExpiration) *Rule {+ s.Expiration = v+ return s+}++// SetID sets the ID field's value.+func (s *Rule) SetID(v string) *Rule {+ s.ID = &v+ return s+}++// SetNoncurrentVersionExpiration sets the NoncurrentVersionExpiration field's value.+func (s *Rule) SetNoncurrentVersionExpiration(v *NoncurrentVersionExpiration) *Rule {+ s.NoncurrentVersionExpiration = v+ return s+}++// SetNoncurrentVersionTransition sets the NoncurrentVersionTransition field's value.+func (s *Rule) SetNoncurrentVersionTransition(v *NoncurrentVersionTransition) *Rule {+ s.NoncurrentVersionTransition = v+ return s+}++// SetPrefix sets the Prefix field's value.+func (s *Rule) SetPrefix(v string) *Rule {+ s.Prefix = &v+ return s+}++// SetStatus sets the Status field's value.+func (s *Rule) SetStatus(v string) *Rule {+ s.Status = &v+ return s+}++// SetTransition sets the Transition field's value.+func (s *Rule) SetTransition(v *Transition) *Rule {+ s.Transition = v+ return s+}++// Specifies the use of SSE-KMS to encrypt delivered Inventory reports.+type SSEKMS struct {+ _ struct{} `locationName:"SSE-KMS" type:"structure"`++ // Specifies the ID of the AWS Key Management Service (KMS) master encryption+ // key to use for encrypting Inventory reports.+ //+ // KeyId is a required field+ KeyId *string `type:"string" required:"true" sensitive:"true"`+}++// String returns the string representation+func (s SSEKMS) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SSEKMS) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *SSEKMS) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "SSEKMS"}+ if s.KeyId == nil {+ invalidParams.Add(request.NewErrParamRequired("KeyId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetKeyId sets the KeyId field's value.+func (s *SSEKMS) SetKeyId(v string) *SSEKMS {+ s.KeyId = &v+ return s+}++// Specifies the use of SSE-S3 to encrypt delivered Inventory reports.+type SSES3 struct {+ _ struct{} `locationName:"SSE-S3" type:"structure"`+}++// String returns the string representation+func (s SSES3) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SSES3) GoString() string {+ return s.String()+}++// SelectObjectContentEventStream provides handling of EventStreams for+// the SelectObjectContent API.+//+// Use this type to receive SelectObjectContentEventStream events. The events+// can be read from the Events channel member.+//+// The events that can be received are:+//+// * ContinuationEvent+// * EndEvent+// * ProgressEvent+// * RecordsEvent+// * StatsEvent+type SelectObjectContentEventStream struct {+ // Reader is the EventStream reader for the SelectObjectContentEventStream+ // events. This value is automatically set by the SDK when the API call is made+ // Use this member when unit testing your code with the SDK to mock out the+ // EventStream Reader.+ //+ // Must not be nil.+ Reader SelectObjectContentEventStreamReader++ // StreamCloser is the io.Closer for the EventStream connection. For HTTP+ // EventStream this is the response Body. The stream will be closed when+ // the Close method of the EventStream is called.+ StreamCloser io.Closer+}++// Close closes the EventStream. This will also cause the Events channel to be+// closed. You can use the closing of the Events channel to terminate your+// application's read from the API's EventStream.+//+// Will close the underlying EventStream reader. For EventStream over HTTP+// connection this will also close the HTTP connection.+//+// Close must be called when done using the EventStream API. Not calling Close+// may result in resource leaks.+func (es *SelectObjectContentEventStream) Close() (err error) {+ es.Reader.Close()+ return es.Err()+}++// Err returns any error that occurred while reading EventStream Events from+// the service API's response. Returns nil if there were no errors.+func (es *SelectObjectContentEventStream) Err() error {+ if err := es.Reader.Err(); err != nil {+ return err+ }+ es.StreamCloser.Close()++ return nil+}++// Events returns a channel to read EventStream Events from the+// SelectObjectContent API.+//+// These events are:+//+// * ContinuationEvent+// * EndEvent+// * ProgressEvent+// * RecordsEvent+// * StatsEvent+func (es *SelectObjectContentEventStream) Events() <-chan SelectObjectContentEventStreamEvent {+ return es.Reader.Events()+}++// SelectObjectContentEventStreamEvent groups together all EventStream+// events read from the SelectObjectContent API.+//+// These events are:+//+// * ContinuationEvent+// * EndEvent+// * ProgressEvent+// * RecordsEvent+// * StatsEvent+type SelectObjectContentEventStreamEvent interface {+ eventSelectObjectContentEventStream()+}++// SelectObjectContentEventStreamReader provides the interface for reading EventStream+// Events from the SelectObjectContent API. The+// default implementation for this interface will be SelectObjectContentEventStream.+//+// The reader's Close method must allow multiple concurrent calls.+//+// These events are:+//+// * ContinuationEvent+// * EndEvent+// * ProgressEvent+// * RecordsEvent+// * StatsEvent+type SelectObjectContentEventStreamReader interface {+ // Returns a channel of events as they are read from the event stream.+ Events() <-chan SelectObjectContentEventStreamEvent++ // Close will close the underlying event stream reader. For event stream over+ // HTTP this will also close the HTTP connection.+ Close() error++ // Returns any error that has occured while reading from the event stream.+ Err() error+}++type readSelectObjectContentEventStream struct {+ eventReader *eventstreamapi.EventReader+ stream chan SelectObjectContentEventStreamEvent+ errVal atomic.Value++ done chan struct{}+ closeOnce sync.Once+}++func newReadSelectObjectContentEventStream(+ reader io.ReadCloser,+ unmarshalers request.HandlerList,+ logger aws.Logger,+ logLevel aws.LogLevelType,+) *readSelectObjectContentEventStream {+ r := &readSelectObjectContentEventStream{+ stream: make(chan SelectObjectContentEventStreamEvent),+ done: make(chan struct{}),+ }++ r.eventReader = eventstreamapi.NewEventReader(+ reader,+ protocol.HandlerPayloadUnmarshal{+ Unmarshalers: unmarshalers,+ },+ r.unmarshalerForEventType,+ )+ r.eventReader.UseLogger(logger, logLevel)++ return r+}++// Close will close the underlying event stream reader. For EventStream over+// HTTP this will also close the HTTP connection.+func (r *readSelectObjectContentEventStream) Close() error {+ r.closeOnce.Do(r.safeClose)++ return r.Err()+}++func (r *readSelectObjectContentEventStream) safeClose() {+ close(r.done)+ err := r.eventReader.Close()+ if err != nil {+ r.errVal.Store(err)+ }+}++func (r *readSelectObjectContentEventStream) Err() error {+ if v := r.errVal.Load(); v != nil {+ return v.(error)+ }++ return nil+}++func (r *readSelectObjectContentEventStream) Events() <-chan SelectObjectContentEventStreamEvent {+ return r.stream+}++func (r *readSelectObjectContentEventStream) readEventStream() {+ defer close(r.stream)++ for {+ event, err := r.eventReader.ReadEvent()+ if err != nil {+ if err == io.EOF {+ return+ }+ select {+ case <-r.done:+ // If closed already ignore the error+ return+ default:+ }+ r.errVal.Store(err)+ return+ }++ select {+ case r.stream <- event.(SelectObjectContentEventStreamEvent):+ case <-r.done:+ return+ }+ }+}++func (r *readSelectObjectContentEventStream) unmarshalerForEventType(+ eventType string,+) (eventstreamapi.Unmarshaler, error) {+ switch eventType {+ case "Cont":+ return &ContinuationEvent{}, nil++ case "End":+ return &EndEvent{}, nil++ case "Progress":+ return &ProgressEvent{}, nil++ case "Records":+ return &RecordsEvent{}, nil++ case "Stats":+ return &StatsEvent{}, nil+ default:+ return nil, awserr.New(+ request.ErrCodeSerialization,+ fmt.Sprintf("unknown event type name, %s, for SelectObjectContentEventStream", eventType),+ nil,+ )+ }+}++// Request to filter the contents of an Amazon S3 object based on a simple Structured+// Query Language (SQL) statement. In the request, along with the SQL expression,+// you must specify a data serialization format (JSON or CSV) of the object.+// Amazon S3 uses this to parse object data into records. It returns only records+// that match the specified SQL expression. You must also specify the data serialization+// format for the response. For more information, see S3Select API Documentation+// (http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectSELECTContent.html).+type SelectObjectContentInput struct {+ _ struct{} `locationName:"SelectObjectContentRequest" type:"structure" xmlURI:"http://s3.amazonaws.com/doc/2006-03-01/"`++ // The S3 bucket.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The expression that is used to query the object.+ //+ // Expression is a required field+ Expression *string `type:"string" required:"true"`++ // The type of the provided expression (for example., SQL).+ //+ // ExpressionType is a required field+ ExpressionType *string `type:"string" required:"true" enum:"ExpressionType"`++ // Describes the format of the data in the object that is being queried.+ //+ // InputSerialization is a required field+ InputSerialization *InputSerialization `type:"structure" required:"true"`++ // The object key.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Describes the format of the data that you want Amazon S3 to return in response.+ //+ // OutputSerialization is a required field+ OutputSerialization *OutputSerialization `type:"structure" required:"true"`++ // Specifies if periodic request progress information should be enabled.+ RequestProgress *RequestProgress `type:"structure"`++ // The SSE Algorithm used to encrypt the object. For more information, see+ // Server-Side Encryption (Using Customer-Provided Encryption Keys (http://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys.html).+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // The SSE Customer Key. For more information, see Server-Side Encryption (Using+ // Customer-Provided Encryption Keys (http://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys.html).+ SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string" sensitive:"true"`++ // The SSE Customer Key MD5. For more information, see Server-Side Encryption+ // (Using Customer-Provided Encryption Keys (http://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys.html).+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`+}++// String returns the string representation+func (s SelectObjectContentInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SelectObjectContentInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *SelectObjectContentInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "SelectObjectContentInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Expression == nil {+ invalidParams.Add(request.NewErrParamRequired("Expression"))+ }+ if s.ExpressionType == nil {+ invalidParams.Add(request.NewErrParamRequired("ExpressionType"))+ }+ if s.InputSerialization == nil {+ invalidParams.Add(request.NewErrParamRequired("InputSerialization"))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.OutputSerialization == nil {+ invalidParams.Add(request.NewErrParamRequired("OutputSerialization"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *SelectObjectContentInput) SetBucket(v string) *SelectObjectContentInput {+ s.Bucket = &v+ return s+}++func (s *SelectObjectContentInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetExpression sets the Expression field's value.+func (s *SelectObjectContentInput) SetExpression(v string) *SelectObjectContentInput {+ s.Expression = &v+ return s+}++// SetExpressionType sets the ExpressionType field's value.+func (s *SelectObjectContentInput) SetExpressionType(v string) *SelectObjectContentInput {+ s.ExpressionType = &v+ return s+}++// SetInputSerialization sets the InputSerialization field's value.+func (s *SelectObjectContentInput) SetInputSerialization(v *InputSerialization) *SelectObjectContentInput {+ s.InputSerialization = v+ return s+}++// SetKey sets the Key field's value.+func (s *SelectObjectContentInput) SetKey(v string) *SelectObjectContentInput {+ s.Key = &v+ return s+}++// SetOutputSerialization sets the OutputSerialization field's value.+func (s *SelectObjectContentInput) SetOutputSerialization(v *OutputSerialization) *SelectObjectContentInput {+ s.OutputSerialization = v+ return s+}++// SetRequestProgress sets the RequestProgress field's value.+func (s *SelectObjectContentInput) SetRequestProgress(v *RequestProgress) *SelectObjectContentInput {+ s.RequestProgress = v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *SelectObjectContentInput) SetSSECustomerAlgorithm(v string) *SelectObjectContentInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *SelectObjectContentInput) SetSSECustomerKey(v string) *SelectObjectContentInput {+ s.SSECustomerKey = &v+ return s+}++func (s *SelectObjectContentInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *SelectObjectContentInput) SetSSECustomerKeyMD5(v string) *SelectObjectContentInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++type SelectObjectContentOutput struct {+ _ struct{} `type:"structure" payload:"Payload"`++ // Use EventStream to use the API's stream.+ EventStream *SelectObjectContentEventStream `type:"structure"`+}++// String returns the string representation+func (s SelectObjectContentOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SelectObjectContentOutput) GoString() string {+ return s.String()+}++// SetEventStream sets the EventStream field's value.+func (s *SelectObjectContentOutput) SetEventStream(v *SelectObjectContentEventStream) *SelectObjectContentOutput {+ s.EventStream = v+ return s+}++func (s *SelectObjectContentOutput) runEventStreamLoop(r *request.Request) {+ if r.Error != nil {+ return+ }+ reader := newReadSelectObjectContentEventStream(+ r.HTTPResponse.Body,+ r.Handlers.UnmarshalStream,+ r.Config.Logger,+ r.Config.LogLevel.Value(),+ )+ go reader.readEventStream()++ eventStream := &SelectObjectContentEventStream{+ StreamCloser: r.HTTPResponse.Body,+ Reader: reader,+ }+ s.EventStream = eventStream+}++// Describes the parameters for Select job types.+type SelectParameters struct {+ _ struct{} `type:"structure"`++ // The expression that is used to query the object.+ //+ // Expression is a required field+ Expression *string `type:"string" required:"true"`++ // The type of the provided expression (e.g., SQL).+ //+ // ExpressionType is a required field+ ExpressionType *string `type:"string" required:"true" enum:"ExpressionType"`++ // Describes the serialization format of the object.+ //+ // InputSerialization is a required field+ InputSerialization *InputSerialization `type:"structure" required:"true"`++ // Describes how the results of the Select job are serialized.+ //+ // OutputSerialization is a required field+ OutputSerialization *OutputSerialization `type:"structure" required:"true"`+}++// String returns the string representation+func (s SelectParameters) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SelectParameters) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *SelectParameters) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "SelectParameters"}+ if s.Expression == nil {+ invalidParams.Add(request.NewErrParamRequired("Expression"))+ }+ if s.ExpressionType == nil {+ invalidParams.Add(request.NewErrParamRequired("ExpressionType"))+ }+ if s.InputSerialization == nil {+ invalidParams.Add(request.NewErrParamRequired("InputSerialization"))+ }+ if s.OutputSerialization == nil {+ invalidParams.Add(request.NewErrParamRequired("OutputSerialization"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetExpression sets the Expression field's value.+func (s *SelectParameters) SetExpression(v string) *SelectParameters {+ s.Expression = &v+ return s+}++// SetExpressionType sets the ExpressionType field's value.+func (s *SelectParameters) SetExpressionType(v string) *SelectParameters {+ s.ExpressionType = &v+ return s+}++// SetInputSerialization sets the InputSerialization field's value.+func (s *SelectParameters) SetInputSerialization(v *InputSerialization) *SelectParameters {+ s.InputSerialization = v+ return s+}++// SetOutputSerialization sets the OutputSerialization field's value.+func (s *SelectParameters) SetOutputSerialization(v *OutputSerialization) *SelectParameters {+ s.OutputSerialization = v+ return s+}++// Describes the default server-side encryption to apply to new objects in the+// bucket. If Put Object request does not specify any server-side encryption,+// this default encryption will be applied.+type ServerSideEncryptionByDefault struct {+ _ struct{} `type:"structure"`++ // KMS master key ID to use for the default encryption. This parameter is allowed+ // if SSEAlgorithm is aws:kms.+ KMSMasterKeyID *string `type:"string" sensitive:"true"`++ // Server-side encryption algorithm to use for the default encryption.+ //+ // SSEAlgorithm is a required field+ SSEAlgorithm *string `type:"string" required:"true" enum:"ServerSideEncryption"`+}++// String returns the string representation+func (s ServerSideEncryptionByDefault) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ServerSideEncryptionByDefault) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ServerSideEncryptionByDefault) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ServerSideEncryptionByDefault"}+ if s.SSEAlgorithm == nil {+ invalidParams.Add(request.NewErrParamRequired("SSEAlgorithm"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetKMSMasterKeyID sets the KMSMasterKeyID field's value.+func (s *ServerSideEncryptionByDefault) SetKMSMasterKeyID(v string) *ServerSideEncryptionByDefault {+ s.KMSMasterKeyID = &v+ return s+}++// SetSSEAlgorithm sets the SSEAlgorithm field's value.+func (s *ServerSideEncryptionByDefault) SetSSEAlgorithm(v string) *ServerSideEncryptionByDefault {+ s.SSEAlgorithm = &v+ return s+}++// Container for server-side encryption configuration rules. Currently S3 supports+// one rule only.+type ServerSideEncryptionConfiguration struct {+ _ struct{} `type:"structure"`++ // Container for information about a particular server-side encryption configuration+ // rule.+ //+ // Rules is a required field+ Rules []*ServerSideEncryptionRule `locationName:"Rule" type:"list" flattened:"true" required:"true"`+}++// String returns the string representation+func (s ServerSideEncryptionConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ServerSideEncryptionConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ServerSideEncryptionConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ServerSideEncryptionConfiguration"}+ if s.Rules == nil {+ invalidParams.Add(request.NewErrParamRequired("Rules"))+ }+ if s.Rules != nil {+ for i, v := range s.Rules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Rules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetRules sets the Rules field's value.+func (s *ServerSideEncryptionConfiguration) SetRules(v []*ServerSideEncryptionRule) *ServerSideEncryptionConfiguration {+ s.Rules = v+ return s+}++// Container for information about a particular server-side encryption configuration+// rule.+type ServerSideEncryptionRule struct {+ _ struct{} `type:"structure"`++ // Describes the default server-side encryption to apply to new objects in the+ // bucket. If Put Object request does not specify any server-side encryption,+ // this default encryption will be applied.+ ApplyServerSideEncryptionByDefault *ServerSideEncryptionByDefault `type:"structure"`+}++// String returns the string representation+func (s ServerSideEncryptionRule) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s ServerSideEncryptionRule) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *ServerSideEncryptionRule) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "ServerSideEncryptionRule"}+ if s.ApplyServerSideEncryptionByDefault != nil {+ if err := s.ApplyServerSideEncryptionByDefault.Validate(); err != nil {+ invalidParams.AddNested("ApplyServerSideEncryptionByDefault", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetApplyServerSideEncryptionByDefault sets the ApplyServerSideEncryptionByDefault field's value.+func (s *ServerSideEncryptionRule) SetApplyServerSideEncryptionByDefault(v *ServerSideEncryptionByDefault) *ServerSideEncryptionRule {+ s.ApplyServerSideEncryptionByDefault = v+ return s+}++// A container for filters that define which source objects should be replicated.+type SourceSelectionCriteria struct {+ _ struct{} `type:"structure"`++ // A container for filter information for the selection of S3 objects encrypted+ // with AWS KMS. If you include SourceSelectionCriteria in the replication configuration,+ // this element is required.+ SseKmsEncryptedObjects *SseKmsEncryptedObjects `type:"structure"`+}++// String returns the string representation+func (s SourceSelectionCriteria) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SourceSelectionCriteria) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *SourceSelectionCriteria) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "SourceSelectionCriteria"}+ if s.SseKmsEncryptedObjects != nil {+ if err := s.SseKmsEncryptedObjects.Validate(); err != nil {+ invalidParams.AddNested("SseKmsEncryptedObjects", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetSseKmsEncryptedObjects sets the SseKmsEncryptedObjects field's value.+func (s *SourceSelectionCriteria) SetSseKmsEncryptedObjects(v *SseKmsEncryptedObjects) *SourceSelectionCriteria {+ s.SseKmsEncryptedObjects = v+ return s+}++// A container for filter information for the selection of S3 objects encrypted+// with AWS KMS.+type SseKmsEncryptedObjects struct {+ _ struct{} `type:"structure"`++ // If the status is not Enabled, replication for S3 objects encrypted with AWS+ // KMS is disabled.+ //+ // Status is a required field+ Status *string `type:"string" required:"true" enum:"SseKmsEncryptedObjectsStatus"`+}++// String returns the string representation+func (s SseKmsEncryptedObjects) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s SseKmsEncryptedObjects) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *SseKmsEncryptedObjects) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "SseKmsEncryptedObjects"}+ if s.Status == nil {+ invalidParams.Add(request.NewErrParamRequired("Status"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetStatus sets the Status field's value.+func (s *SseKmsEncryptedObjects) SetStatus(v string) *SseKmsEncryptedObjects {+ s.Status = &v+ return s+}++type Stats struct {+ _ struct{} `type:"structure"`++ // The total number of uncompressed object bytes processed.+ BytesProcessed *int64 `type:"long"`++ // The total number of bytes of records payload data returned.+ BytesReturned *int64 `type:"long"`++ // The total number of object bytes scanned.+ BytesScanned *int64 `type:"long"`+}++// String returns the string representation+func (s Stats) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Stats) GoString() string {+ return s.String()+}++// SetBytesProcessed sets the BytesProcessed field's value.+func (s *Stats) SetBytesProcessed(v int64) *Stats {+ s.BytesProcessed = &v+ return s+}++// SetBytesReturned sets the BytesReturned field's value.+func (s *Stats) SetBytesReturned(v int64) *Stats {+ s.BytesReturned = &v+ return s+}++// SetBytesScanned sets the BytesScanned field's value.+func (s *Stats) SetBytesScanned(v int64) *Stats {+ s.BytesScanned = &v+ return s+}++type StatsEvent struct {+ _ struct{} `locationName:"StatsEvent" type:"structure" payload:"Details"`++ // The Stats event details.+ Details *Stats `locationName:"Details" type:"structure"`+}++// String returns the string representation+func (s StatsEvent) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s StatsEvent) GoString() string {+ return s.String()+}++// SetDetails sets the Details field's value.+func (s *StatsEvent) SetDetails(v *Stats) *StatsEvent {+ s.Details = v+ return s+}++// The StatsEvent is and event in the SelectObjectContentEventStream group of events.+func (s *StatsEvent) eventSelectObjectContentEventStream() {}++// UnmarshalEvent unmarshals the EventStream Message into the StatsEvent value.+// This method is only used internally within the SDK's EventStream handling.+func (s *StatsEvent) UnmarshalEvent(+ payloadUnmarshaler protocol.PayloadUnmarshaler,+ msg eventstream.Message,+) error {+ if err := payloadUnmarshaler.UnmarshalPayload(+ bytes.NewReader(msg.Payload), s,+ ); err != nil {+ return err+ }+ return nil+}++type StorageClassAnalysis struct {+ _ struct{} `type:"structure"`++ // A container used to describe how data related to the storage class analysis+ // should be exported.+ DataExport *StorageClassAnalysisDataExport `type:"structure"`+}++// String returns the string representation+func (s StorageClassAnalysis) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s StorageClassAnalysis) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *StorageClassAnalysis) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "StorageClassAnalysis"}+ if s.DataExport != nil {+ if err := s.DataExport.Validate(); err != nil {+ invalidParams.AddNested("DataExport", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDataExport sets the DataExport field's value.+func (s *StorageClassAnalysis) SetDataExport(v *StorageClassAnalysisDataExport) *StorageClassAnalysis {+ s.DataExport = v+ return s+}++type StorageClassAnalysisDataExport struct {+ _ struct{} `type:"structure"`++ // The place to store the data for an analysis.+ //+ // Destination is a required field+ Destination *AnalyticsExportDestination `type:"structure" required:"true"`++ // The version of the output schema to use when exporting data. Must be V_1.+ //+ // OutputSchemaVersion is a required field+ OutputSchemaVersion *string `type:"string" required:"true" enum:"StorageClassAnalysisSchemaVersion"`+}++// String returns the string representation+func (s StorageClassAnalysisDataExport) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s StorageClassAnalysisDataExport) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *StorageClassAnalysisDataExport) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "StorageClassAnalysisDataExport"}+ if s.Destination == nil {+ invalidParams.Add(request.NewErrParamRequired("Destination"))+ }+ if s.OutputSchemaVersion == nil {+ invalidParams.Add(request.NewErrParamRequired("OutputSchemaVersion"))+ }+ if s.Destination != nil {+ if err := s.Destination.Validate(); err != nil {+ invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDestination sets the Destination field's value.+func (s *StorageClassAnalysisDataExport) SetDestination(v *AnalyticsExportDestination) *StorageClassAnalysisDataExport {+ s.Destination = v+ return s+}++// SetOutputSchemaVersion sets the OutputSchemaVersion field's value.+func (s *StorageClassAnalysisDataExport) SetOutputSchemaVersion(v string) *StorageClassAnalysisDataExport {+ s.OutputSchemaVersion = &v+ return s+}++type Tag struct {+ _ struct{} `type:"structure"`++ // Name of the tag.+ //+ // Key is a required field+ Key *string `min:"1" type:"string" required:"true"`++ // Value of the tag.+ //+ // Value is a required field+ Value *string `type:"string" required:"true"`+}++// String returns the string representation+func (s Tag) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Tag) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Tag) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Tag"}+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.Value == nil {+ invalidParams.Add(request.NewErrParamRequired("Value"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetKey sets the Key field's value.+func (s *Tag) SetKey(v string) *Tag {+ s.Key = &v+ return s+}++// SetValue sets the Value field's value.+func (s *Tag) SetValue(v string) *Tag {+ s.Value = &v+ return s+}++type Tagging struct {+ _ struct{} `type:"structure"`++ // TagSet is a required field+ TagSet []*Tag `locationNameList:"Tag" type:"list" required:"true"`+}++// String returns the string representation+func (s Tagging) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Tagging) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *Tagging) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "Tagging"}+ if s.TagSet == nil {+ invalidParams.Add(request.NewErrParamRequired("TagSet"))+ }+ if s.TagSet != nil {+ for i, v := range s.TagSet {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TagSet", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetTagSet sets the TagSet field's value.+func (s *Tagging) SetTagSet(v []*Tag) *Tagging {+ s.TagSet = v+ return s+}++type TargetGrant struct {+ _ struct{} `type:"structure"`++ Grantee *Grantee `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`++ // Logging permissions assigned to the Grantee for the bucket.+ Permission *string `type:"string" enum:"BucketLogsPermission"`+}++// String returns the string representation+func (s TargetGrant) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s TargetGrant) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *TargetGrant) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "TargetGrant"}+ if s.Grantee != nil {+ if err := s.Grantee.Validate(); err != nil {+ invalidParams.AddNested("Grantee", err.(request.ErrInvalidParams))+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetGrantee sets the Grantee field's value.+func (s *TargetGrant) SetGrantee(v *Grantee) *TargetGrant {+ s.Grantee = v+ return s+}++// SetPermission sets the Permission field's value.+func (s *TargetGrant) SetPermission(v string) *TargetGrant {+ s.Permission = &v+ return s+}++// A container for specifying the configuration for publication of messages+// to an Amazon Simple Notification Service (Amazon SNS) topic.when Amazon S3+// detects specified events.+type TopicConfiguration struct {+ _ struct{} `type:"structure"`++ // Events is a required field+ Events []*string `locationName:"Event" type:"list" flattened:"true" required:"true"`++ // A container for object key name filtering rules. For information about key+ // name filtering, see Configuring Event Notifications (http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html)+ // in the Amazon Simple Storage Service Developer Guide.+ Filter *NotificationConfigurationFilter `type:"structure"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ // The Amazon Resource Name (ARN) of the Amazon SNS topic to which Amazon S3+ // will publish a message when it detects events of the specified type.+ //+ // TopicArn is a required field+ TopicArn *string `locationName:"Topic" type:"string" required:"true"`+}++// String returns the string representation+func (s TopicConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s TopicConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *TopicConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "TopicConfiguration"}+ if s.Events == nil {+ invalidParams.Add(request.NewErrParamRequired("Events"))+ }+ if s.TopicArn == nil {+ invalidParams.Add(request.NewErrParamRequired("TopicArn"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetEvents sets the Events field's value.+func (s *TopicConfiguration) SetEvents(v []*string) *TopicConfiguration {+ s.Events = v+ return s+}++// SetFilter sets the Filter field's value.+func (s *TopicConfiguration) SetFilter(v *NotificationConfigurationFilter) *TopicConfiguration {+ s.Filter = v+ return s+}++// SetId sets the Id field's value.+func (s *TopicConfiguration) SetId(v string) *TopicConfiguration {+ s.Id = &v+ return s+}++// SetTopicArn sets the TopicArn field's value.+func (s *TopicConfiguration) SetTopicArn(v string) *TopicConfiguration {+ s.TopicArn = &v+ return s+}++type TopicConfigurationDeprecated struct {+ _ struct{} `type:"structure"`++ // Bucket event for which to send notifications.+ //+ // Deprecated: Event has been deprecated+ Event *string `deprecated:"true" type:"string" enum:"Event"`++ Events []*string `locationName:"Event" type:"list" flattened:"true"`++ // An optional unique identifier for configurations in a notification configuration.+ // If you don't provide one, Amazon S3 will assign an ID.+ Id *string `type:"string"`++ // Amazon SNS topic to which Amazon S3 will publish a message to report the+ // specified events for the bucket.+ Topic *string `type:"string"`+}++// String returns the string representation+func (s TopicConfigurationDeprecated) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s TopicConfigurationDeprecated) GoString() string {+ return s.String()+}++// SetEvent sets the Event field's value.+func (s *TopicConfigurationDeprecated) SetEvent(v string) *TopicConfigurationDeprecated {+ s.Event = &v+ return s+}++// SetEvents sets the Events field's value.+func (s *TopicConfigurationDeprecated) SetEvents(v []*string) *TopicConfigurationDeprecated {+ s.Events = v+ return s+}++// SetId sets the Id field's value.+func (s *TopicConfigurationDeprecated) SetId(v string) *TopicConfigurationDeprecated {+ s.Id = &v+ return s+}++// SetTopic sets the Topic field's value.+func (s *TopicConfigurationDeprecated) SetTopic(v string) *TopicConfigurationDeprecated {+ s.Topic = &v+ return s+}++type Transition struct {+ _ struct{} `type:"structure"`++ // Indicates at what date the object is to be moved or deleted. Should be in+ // GMT ISO 8601 Format.+ Date *time.Time `type:"timestamp" timestampFormat:"iso8601"`++ // Indicates the lifetime, in days, of the objects that are subject to the rule.+ // The value must be a non-zero positive integer.+ Days *int64 `type:"integer"`++ // The class of storage used to store the object.+ StorageClass *string `type:"string" enum:"TransitionStorageClass"`+}++// String returns the string representation+func (s Transition) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Transition) GoString() string {+ return s.String()+}++// SetDate sets the Date field's value.+func (s *Transition) SetDate(v time.Time) *Transition {+ s.Date = &v+ return s+}++// SetDays sets the Days field's value.+func (s *Transition) SetDays(v int64) *Transition {+ s.Days = &v+ return s+}++// SetStorageClass sets the StorageClass field's value.+func (s *Transition) SetStorageClass(v string) *Transition {+ s.StorageClass = &v+ return s+}++type UploadPartCopyInput struct {+ _ struct{} `type:"structure"`++ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // The name of the source bucket and key name of the source object, separated+ // by a slash (/). Must be URL-encoded.+ //+ // CopySource is a required field+ CopySource *string `location:"header" locationName:"x-amz-copy-source" type:"string" required:"true"`++ // Copies the object if its entity tag (ETag) matches the specified tag.+ CopySourceIfMatch *string `location:"header" locationName:"x-amz-copy-source-if-match" type:"string"`++ // Copies the object if it has been modified since the specified time.+ CopySourceIfModifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-modified-since" type:"timestamp"`++ // Copies the object if its entity tag (ETag) is different than the specified+ // ETag.+ CopySourceIfNoneMatch *string `location:"header" locationName:"x-amz-copy-source-if-none-match" type:"string"`++ // Copies the object if it hasn't been modified since the specified time.+ CopySourceIfUnmodifiedSince *time.Time `location:"header" locationName:"x-amz-copy-source-if-unmodified-since" type:"timestamp"`++ // The range of bytes to copy from the source object. The range value must use+ // the form bytes=first-last, where the first and last are the zero-based byte+ // offsets to copy. For example, bytes=0-9 indicates that you want to copy the+ // first ten bytes of the source. You can copy a range only if the source object+ // is greater than 5 GB.+ CopySourceRange *string `location:"header" locationName:"x-amz-copy-source-range" type:"string"`++ // Specifies the algorithm to use when decrypting the source object (e.g., AES256).+ CopySourceSSECustomerAlgorithm *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-algorithm" type:"string"`++ // Specifies the customer-provided encryption key for Amazon S3 to use to decrypt+ // the source object. The encryption key provided in this header must be one+ // that was used when the source object was created.+ CopySourceSSECustomerKey *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key" type:"string" sensitive:"true"`++ // 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.+ CopySourceSSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-copy-source-server-side-encryption-customer-key-MD5" type:"string"`++ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Part number of part being copied. This is a positive integer between 1 and+ // 10,000.+ //+ // PartNumber is a required field+ PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer" required:"true"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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. This must be the same encryption key specified in the initiate multipart+ // upload request.+ SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string" sensitive:"true"`++ // 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"`++ // Upload ID identifying the multipart upload whose part is being copied.+ //+ // UploadId is a required field+ UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`+}++// String returns the string representation+func (s UploadPartCopyInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s UploadPartCopyInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *UploadPartCopyInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "UploadPartCopyInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.CopySource == nil {+ invalidParams.Add(request.NewErrParamRequired("CopySource"))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.PartNumber == nil {+ invalidParams.Add(request.NewErrParamRequired("PartNumber"))+ }+ if s.UploadId == nil {+ invalidParams.Add(request.NewErrParamRequired("UploadId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBucket sets the Bucket field's value.+func (s *UploadPartCopyInput) SetBucket(v string) *UploadPartCopyInput {+ s.Bucket = &v+ return s+}++func (s *UploadPartCopyInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetCopySource sets the CopySource field's value.+func (s *UploadPartCopyInput) SetCopySource(v string) *UploadPartCopyInput {+ s.CopySource = &v+ return s+}++// SetCopySourceIfMatch sets the CopySourceIfMatch field's value.+func (s *UploadPartCopyInput) SetCopySourceIfMatch(v string) *UploadPartCopyInput {+ s.CopySourceIfMatch = &v+ return s+}++// SetCopySourceIfModifiedSince sets the CopySourceIfModifiedSince field's value.+func (s *UploadPartCopyInput) SetCopySourceIfModifiedSince(v time.Time) *UploadPartCopyInput {+ s.CopySourceIfModifiedSince = &v+ return s+}++// SetCopySourceIfNoneMatch sets the CopySourceIfNoneMatch field's value.+func (s *UploadPartCopyInput) SetCopySourceIfNoneMatch(v string) *UploadPartCopyInput {+ s.CopySourceIfNoneMatch = &v+ return s+}++// SetCopySourceIfUnmodifiedSince sets the CopySourceIfUnmodifiedSince field's value.+func (s *UploadPartCopyInput) SetCopySourceIfUnmodifiedSince(v time.Time) *UploadPartCopyInput {+ s.CopySourceIfUnmodifiedSince = &v+ return s+}++// SetCopySourceRange sets the CopySourceRange field's value.+func (s *UploadPartCopyInput) SetCopySourceRange(v string) *UploadPartCopyInput {+ s.CopySourceRange = &v+ return s+}++// SetCopySourceSSECustomerAlgorithm sets the CopySourceSSECustomerAlgorithm field's value.+func (s *UploadPartCopyInput) SetCopySourceSSECustomerAlgorithm(v string) *UploadPartCopyInput {+ s.CopySourceSSECustomerAlgorithm = &v+ return s+}++// SetCopySourceSSECustomerKey sets the CopySourceSSECustomerKey field's value.+func (s *UploadPartCopyInput) SetCopySourceSSECustomerKey(v string) *UploadPartCopyInput {+ s.CopySourceSSECustomerKey = &v+ return s+}++func (s *UploadPartCopyInput) getCopySourceSSECustomerKey() (v string) {+ if s.CopySourceSSECustomerKey == nil {+ return v+ }+ return *s.CopySourceSSECustomerKey+}++// SetCopySourceSSECustomerKeyMD5 sets the CopySourceSSECustomerKeyMD5 field's value.+func (s *UploadPartCopyInput) SetCopySourceSSECustomerKeyMD5(v string) *UploadPartCopyInput {+ s.CopySourceSSECustomerKeyMD5 = &v+ return s+}++// SetKey sets the Key field's value.+func (s *UploadPartCopyInput) SetKey(v string) *UploadPartCopyInput {+ s.Key = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *UploadPartCopyInput) SetPartNumber(v int64) *UploadPartCopyInput {+ s.PartNumber = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *UploadPartCopyInput) SetRequestPayer(v string) *UploadPartCopyInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *UploadPartCopyInput) SetSSECustomerAlgorithm(v string) *UploadPartCopyInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *UploadPartCopyInput) SetSSECustomerKey(v string) *UploadPartCopyInput {+ s.SSECustomerKey = &v+ return s+}++func (s *UploadPartCopyInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *UploadPartCopyInput) SetSSECustomerKeyMD5(v string) *UploadPartCopyInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *UploadPartCopyInput) SetUploadId(v string) *UploadPartCopyInput {+ s.UploadId = &v+ return s+}++type UploadPartCopyOutput struct {+ _ struct{} `type:"structure" payload:"CopyPartResult"`++ CopyPartResult *CopyPartResult `type:"structure"`++ // The version of the source object that was copied, if you have enabled versioning+ // on the source bucket.+ CopySourceVersionId *string `location:"header" locationName:"x-amz-copy-source-version-id" type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`+}++// String returns the string representation+func (s UploadPartCopyOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s UploadPartCopyOutput) GoString() string {+ return s.String()+}++// SetCopyPartResult sets the CopyPartResult field's value.+func (s *UploadPartCopyOutput) SetCopyPartResult(v *CopyPartResult) *UploadPartCopyOutput {+ s.CopyPartResult = v+ return s+}++// SetCopySourceVersionId sets the CopySourceVersionId field's value.+func (s *UploadPartCopyOutput) SetCopySourceVersionId(v string) *UploadPartCopyOutput {+ s.CopySourceVersionId = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *UploadPartCopyOutput) SetRequestCharged(v string) *UploadPartCopyOutput {+ s.RequestCharged = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *UploadPartCopyOutput) SetSSECustomerAlgorithm(v string) *UploadPartCopyOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *UploadPartCopyOutput) SetSSECustomerKeyMD5(v string) *UploadPartCopyOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *UploadPartCopyOutput) SetSSEKMSKeyId(v string) *UploadPartCopyOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *UploadPartCopyOutput) SetServerSideEncryption(v string) *UploadPartCopyOutput {+ s.ServerSideEncryption = &v+ return s+}++type UploadPartInput struct {+ _ struct{} `type:"structure" payload:"Body"`++ // Object data.+ Body io.ReadSeeker `type:"blob"`++ // Name of the bucket to which the multipart upload was initiated.+ //+ // Bucket is a required field+ Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`++ // Size of the body in bytes. This parameter is useful when the size of the+ // body cannot be determined automatically.+ ContentLength *int64 `location:"header" locationName:"Content-Length" type:"long"`++ // The base64-encoded 128-bit MD5 digest of the part data.+ ContentMD5 *string `location:"header" locationName:"Content-MD5" type:"string"`++ // Object key for which the multipart upload was initiated.+ //+ // Key is a required field+ Key *string `location:"uri" locationName:"Key" min:"1" type:"string" required:"true"`++ // Part number of part being uploaded. This is a positive integer between 1+ // and 10,000.+ //+ // PartNumber is a required field+ PartNumber *int64 `location:"querystring" locationName:"partNumber" type:"integer" required:"true"`++ // 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" enum:"RequestPayer"`++ // Specifies the algorithm to use to when encrypting the object (e.g., AES256).+ 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. This must be the same encryption key specified in the initiate multipart+ // upload request.+ SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string" sensitive:"true"`++ // 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"`++ // Upload ID identifying the multipart upload whose part is being uploaded.+ //+ // UploadId is a required field+ UploadId *string `location:"querystring" locationName:"uploadId" type:"string" required:"true"`+}++// String returns the string representation+func (s UploadPartInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s UploadPartInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *UploadPartInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "UploadPartInput"}+ if s.Bucket == nil {+ invalidParams.Add(request.NewErrParamRequired("Bucket"))+ }+ if s.Bucket != nil && len(*s.Bucket) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Bucket", 1))+ }+ if s.Key == nil {+ invalidParams.Add(request.NewErrParamRequired("Key"))+ }+ if s.Key != nil && len(*s.Key) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Key", 1))+ }+ if s.PartNumber == nil {+ invalidParams.Add(request.NewErrParamRequired("PartNumber"))+ }+ if s.UploadId == nil {+ invalidParams.Add(request.NewErrParamRequired("UploadId"))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetBody sets the Body field's value.+func (s *UploadPartInput) SetBody(v io.ReadSeeker) *UploadPartInput {+ s.Body = v+ return s+}++// SetBucket sets the Bucket field's value.+func (s *UploadPartInput) SetBucket(v string) *UploadPartInput {+ s.Bucket = &v+ return s+}++func (s *UploadPartInput) getBucket() (v string) {+ if s.Bucket == nil {+ return v+ }+ return *s.Bucket+}++// SetContentLength sets the ContentLength field's value.+func (s *UploadPartInput) SetContentLength(v int64) *UploadPartInput {+ s.ContentLength = &v+ return s+}++// SetContentMD5 sets the ContentMD5 field's value.+func (s *UploadPartInput) SetContentMD5(v string) *UploadPartInput {+ s.ContentMD5 = &v+ return s+}++// SetKey sets the Key field's value.+func (s *UploadPartInput) SetKey(v string) *UploadPartInput {+ s.Key = &v+ return s+}++// SetPartNumber sets the PartNumber field's value.+func (s *UploadPartInput) SetPartNumber(v int64) *UploadPartInput {+ s.PartNumber = &v+ return s+}++// SetRequestPayer sets the RequestPayer field's value.+func (s *UploadPartInput) SetRequestPayer(v string) *UploadPartInput {+ s.RequestPayer = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *UploadPartInput) SetSSECustomerAlgorithm(v string) *UploadPartInput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKey sets the SSECustomerKey field's value.+func (s *UploadPartInput) SetSSECustomerKey(v string) *UploadPartInput {+ s.SSECustomerKey = &v+ return s+}++func (s *UploadPartInput) getSSECustomerKey() (v string) {+ if s.SSECustomerKey == nil {+ return v+ }+ return *s.SSECustomerKey+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *UploadPartInput) SetSSECustomerKeyMD5(v string) *UploadPartInput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetUploadId sets the UploadId field's value.+func (s *UploadPartInput) SetUploadId(v string) *UploadPartInput {+ s.UploadId = &v+ return s+}++type UploadPartOutput struct {+ _ struct{} `type:"structure"`++ // Entity tag for the uploaded object.+ ETag *string `location:"header" locationName:"ETag" type:"string"`++ // If present, indicates that the requester was successfully charged for the+ // request.+ RequestCharged *string `location:"header" locationName:"x-amz-request-charged" type:"string" enum:"RequestCharged"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header confirming the encryption algorithm+ // used.+ SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`++ // If server-side encryption with a customer-provided encryption key was requested,+ // the response will include this header to provide round trip message integrity+ // verification of the customer-provided encryption key.+ SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`++ // If present, specifies the ID of the AWS Key Management Service (KMS) master+ // encryption key that was used for the object.+ SSEKMSKeyId *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string" sensitive:"true"`++ // 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" enum:"ServerSideEncryption"`+}++// String returns the string representation+func (s UploadPartOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s UploadPartOutput) GoString() string {+ return s.String()+}++// SetETag sets the ETag field's value.+func (s *UploadPartOutput) SetETag(v string) *UploadPartOutput {+ s.ETag = &v+ return s+}++// SetRequestCharged sets the RequestCharged field's value.+func (s *UploadPartOutput) SetRequestCharged(v string) *UploadPartOutput {+ s.RequestCharged = &v+ return s+}++// SetSSECustomerAlgorithm sets the SSECustomerAlgorithm field's value.+func (s *UploadPartOutput) SetSSECustomerAlgorithm(v string) *UploadPartOutput {+ s.SSECustomerAlgorithm = &v+ return s+}++// SetSSECustomerKeyMD5 sets the SSECustomerKeyMD5 field's value.+func (s *UploadPartOutput) SetSSECustomerKeyMD5(v string) *UploadPartOutput {+ s.SSECustomerKeyMD5 = &v+ return s+}++// SetSSEKMSKeyId sets the SSEKMSKeyId field's value.+func (s *UploadPartOutput) SetSSEKMSKeyId(v string) *UploadPartOutput {+ s.SSEKMSKeyId = &v+ return s+}++// SetServerSideEncryption sets the ServerSideEncryption field's value.+func (s *UploadPartOutput) SetServerSideEncryption(v string) *UploadPartOutput {+ s.ServerSideEncryption = &v+ return s+}++type VersioningConfiguration struct {+ _ struct{} `type:"structure"`++ // Specifies whether MFA delete is enabled in the bucket versioning configuration.+ // This element is only returned if the bucket has been configured with MFA+ // delete. If the bucket has never been so configured, this element is not returned.+ MFADelete *string `locationName:"MfaDelete" type:"string" enum:"MFADelete"`++ // The versioning state of the bucket.+ Status *string `type:"string" enum:"BucketVersioningStatus"`+}++// String returns the string representation+func (s VersioningConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s VersioningConfiguration) GoString() string {+ return s.String()+}++// SetMFADelete sets the MFADelete field's value.+func (s *VersioningConfiguration) SetMFADelete(v string) *VersioningConfiguration {+ s.MFADelete = &v+ return s+}++// SetStatus sets the Status field's value.+func (s *VersioningConfiguration) SetStatus(v string) *VersioningConfiguration {+ s.Status = &v+ return s+}++type WebsiteConfiguration struct {+ _ struct{} `type:"structure"`++ ErrorDocument *ErrorDocument `type:"structure"`++ IndexDocument *IndexDocument `type:"structure"`++ RedirectAllRequestsTo *RedirectAllRequestsTo `type:"structure"`++ RoutingRules []*RoutingRule `locationNameList:"RoutingRule" type:"list"`+}++// String returns the string representation+func (s WebsiteConfiguration) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s WebsiteConfiguration) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *WebsiteConfiguration) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "WebsiteConfiguration"}+ if s.ErrorDocument != nil {+ if err := s.ErrorDocument.Validate(); err != nil {+ invalidParams.AddNested("ErrorDocument", err.(request.ErrInvalidParams))+ }+ }+ if s.IndexDocument != nil {+ if err := s.IndexDocument.Validate(); err != nil {+ invalidParams.AddNested("IndexDocument", err.(request.ErrInvalidParams))+ }+ }+ if s.RedirectAllRequestsTo != nil {+ if err := s.RedirectAllRequestsTo.Validate(); err != nil {+ invalidParams.AddNested("RedirectAllRequestsTo", err.(request.ErrInvalidParams))+ }+ }+ if s.RoutingRules != nil {+ for i, v := range s.RoutingRules {+ if v == nil {+ continue+ }+ if err := v.Validate(); err != nil {+ invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RoutingRules", i), err.(request.ErrInvalidParams))+ }+ }+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetErrorDocument sets the ErrorDocument field's value.+func (s *WebsiteConfiguration) SetErrorDocument(v *ErrorDocument) *WebsiteConfiguration {+ s.ErrorDocument = v+ return s+}++// SetIndexDocument sets the IndexDocument field's value.+func (s *WebsiteConfiguration) SetIndexDocument(v *IndexDocument) *WebsiteConfiguration {+ s.IndexDocument = v+ return s+}++// SetRedirectAllRequestsTo sets the RedirectAllRequestsTo field's value.+func (s *WebsiteConfiguration) SetRedirectAllRequestsTo(v *RedirectAllRequestsTo) *WebsiteConfiguration {+ s.RedirectAllRequestsTo = v+ return s+}++// SetRoutingRules sets the RoutingRules field's value.+func (s *WebsiteConfiguration) SetRoutingRules(v []*RoutingRule) *WebsiteConfiguration {+ s.RoutingRules = v+ return s+}++const (+ // AnalyticsS3ExportFileFormatCsv is a AnalyticsS3ExportFileFormat enum value+ AnalyticsS3ExportFileFormatCsv = "CSV"+)++const (+ // BucketAccelerateStatusEnabled is a BucketAccelerateStatus enum value+ BucketAccelerateStatusEnabled = "Enabled"++ // BucketAccelerateStatusSuspended is a BucketAccelerateStatus enum value+ BucketAccelerateStatusSuspended = "Suspended"+)++const (+ // BucketCannedACLPrivate is a BucketCannedACL enum value+ BucketCannedACLPrivate = "private"++ // BucketCannedACLPublicRead is a BucketCannedACL enum value+ BucketCannedACLPublicRead = "public-read"++ // BucketCannedACLPublicReadWrite is a BucketCannedACL enum value+ BucketCannedACLPublicReadWrite = "public-read-write"++ // BucketCannedACLAuthenticatedRead is a BucketCannedACL enum value+ BucketCannedACLAuthenticatedRead = "authenticated-read"+)++const (+ // BucketLocationConstraintEu is a BucketLocationConstraint enum value+ BucketLocationConstraintEu = "EU"++ // BucketLocationConstraintEuWest1 is a BucketLocationConstraint enum value+ BucketLocationConstraintEuWest1 = "eu-west-1"++ // BucketLocationConstraintUsWest1 is a BucketLocationConstraint enum value+ BucketLocationConstraintUsWest1 = "us-west-1"++ // BucketLocationConstraintUsWest2 is a BucketLocationConstraint enum value+ BucketLocationConstraintUsWest2 = "us-west-2"++ // BucketLocationConstraintApSouth1 is a BucketLocationConstraint enum value+ BucketLocationConstraintApSouth1 = "ap-south-1"++ // BucketLocationConstraintApSoutheast1 is a BucketLocationConstraint enum value+ BucketLocationConstraintApSoutheast1 = "ap-southeast-1"++ // BucketLocationConstraintApSoutheast2 is a BucketLocationConstraint enum value+ BucketLocationConstraintApSoutheast2 = "ap-southeast-2"++ // BucketLocationConstraintApNortheast1 is a BucketLocationConstraint enum value+ BucketLocationConstraintApNortheast1 = "ap-northeast-1"++ // BucketLocationConstraintSaEast1 is a BucketLocationConstraint enum value+ BucketLocationConstraintSaEast1 = "sa-east-1"++ // BucketLocationConstraintCnNorth1 is a BucketLocationConstraint enum value+ BucketLocationConstraintCnNorth1 = "cn-north-1"++ // BucketLocationConstraintEuCentral1 is a BucketLocationConstraint enum value+ BucketLocationConstraintEuCentral1 = "eu-central-1"+)++const (+ // BucketLogsPermissionFullControl is a BucketLogsPermission enum value+ BucketLogsPermissionFullControl = "FULL_CONTROL"++ // BucketLogsPermissionRead is a BucketLogsPermission enum value+ BucketLogsPermissionRead = "READ"++ // BucketLogsPermissionWrite is a BucketLogsPermission enum value+ BucketLogsPermissionWrite = "WRITE"+)++const (+ // BucketVersioningStatusEnabled is a BucketVersioningStatus enum value+ BucketVersioningStatusEnabled = "Enabled"++ // BucketVersioningStatusSuspended is a BucketVersioningStatus enum value+ BucketVersioningStatusSuspended = "Suspended"+)++const (+ // CompressionTypeNone is a CompressionType enum value+ CompressionTypeNone = "NONE"++ // CompressionTypeGzip is a CompressionType enum value+ CompressionTypeGzip = "GZIP"++ // CompressionTypeBzip2 is a CompressionType enum value+ CompressionTypeBzip2 = "BZIP2"+)++const (+ // DeleteMarkerReplicationStatusEnabled is a DeleteMarkerReplicationStatus enum value+ DeleteMarkerReplicationStatusEnabled = "Enabled"++ // DeleteMarkerReplicationStatusDisabled is a DeleteMarkerReplicationStatus enum value+ DeleteMarkerReplicationStatusDisabled = "Disabled"+)++// Requests Amazon S3 to encode the object keys in the response and specifies+// the encoding method to use. An object key may contain any Unicode character;+// however, XML 1.0 parser cannot parse some characters, such as characters+// with an ASCII value from 0 to 10. For characters that are not supported in+// XML 1.0, you can add this parameter to request that Amazon S3 encode the+// keys in the response.+const (+ // EncodingTypeUrl is a EncodingType enum value+ EncodingTypeUrl = "url"+)++// The bucket event for which to send notifications.+const (+ // EventS3ReducedRedundancyLostObject is a Event enum value+ EventS3ReducedRedundancyLostObject = "s3:ReducedRedundancyLostObject"++ // EventS3ObjectCreated is a Event enum value+ EventS3ObjectCreated = "s3:ObjectCreated:*"++ // EventS3ObjectCreatedPut is a Event enum value+ EventS3ObjectCreatedPut = "s3:ObjectCreated:Put"++ // EventS3ObjectCreatedPost is a Event enum value+ EventS3ObjectCreatedPost = "s3:ObjectCreated:Post"++ // EventS3ObjectCreatedCopy is a Event enum value+ EventS3ObjectCreatedCopy = "s3:ObjectCreated:Copy"++ // EventS3ObjectCreatedCompleteMultipartUpload is a Event enum value+ EventS3ObjectCreatedCompleteMultipartUpload = "s3:ObjectCreated:CompleteMultipartUpload"++ // EventS3ObjectRemoved is a Event enum value+ EventS3ObjectRemoved = "s3:ObjectRemoved:*"++ // EventS3ObjectRemovedDelete is a Event enum value+ EventS3ObjectRemovedDelete = "s3:ObjectRemoved:Delete"++ // EventS3ObjectRemovedDeleteMarkerCreated is a Event enum value+ EventS3ObjectRemovedDeleteMarkerCreated = "s3:ObjectRemoved:DeleteMarkerCreated"++ // EventS3ObjectRestorePost is a Event enum value+ EventS3ObjectRestorePost = "s3:ObjectRestore:Post"++ // EventS3ObjectRestoreCompleted is a Event enum value+ EventS3ObjectRestoreCompleted = "s3:ObjectRestore:Completed"+)++const (+ // ExpirationStatusEnabled is a ExpirationStatus enum value+ ExpirationStatusEnabled = "Enabled"++ // ExpirationStatusDisabled is a ExpirationStatus enum value+ ExpirationStatusDisabled = "Disabled"+)++const (+ // ExpressionTypeSql is a ExpressionType enum value+ ExpressionTypeSql = "SQL"+)++const (+ // FileHeaderInfoUse is a FileHeaderInfo enum value+ FileHeaderInfoUse = "USE"++ // FileHeaderInfoIgnore is a FileHeaderInfo enum value+ FileHeaderInfoIgnore = "IGNORE"++ // FileHeaderInfoNone is a FileHeaderInfo enum value+ FileHeaderInfoNone = "NONE"+)++const (+ // FilterRuleNamePrefix is a FilterRuleName enum value+ FilterRuleNamePrefix = "prefix"++ // FilterRuleNameSuffix is a FilterRuleName enum value+ FilterRuleNameSuffix = "suffix"+)++const (+ // InventoryFormatCsv is a InventoryFormat enum value+ InventoryFormatCsv = "CSV"++ // InventoryFormatOrc is a InventoryFormat enum value+ InventoryFormatOrc = "ORC"++ // InventoryFormatParquet is a InventoryFormat enum value+ InventoryFormatParquet = "Parquet"+)++const (+ // InventoryFrequencyDaily is a InventoryFrequency enum value+ InventoryFrequencyDaily = "Daily"++ // InventoryFrequencyWeekly is a InventoryFrequency enum value+ InventoryFrequencyWeekly = "Weekly"+)++const (+ // InventoryIncludedObjectVersionsAll is a InventoryIncludedObjectVersions enum value+ InventoryIncludedObjectVersionsAll = "All"++ // InventoryIncludedObjectVersionsCurrent is a InventoryIncludedObjectVersions enum value+ InventoryIncludedObjectVersionsCurrent = "Current"+)++const (+ // InventoryOptionalFieldSize is a InventoryOptionalField enum value+ InventoryOptionalFieldSize = "Size"++ // InventoryOptionalFieldLastModifiedDate is a InventoryOptionalField enum value+ InventoryOptionalFieldLastModifiedDate = "LastModifiedDate"++ // InventoryOptionalFieldStorageClass is a InventoryOptionalField enum value+ InventoryOptionalFieldStorageClass = "StorageClass"++ // InventoryOptionalFieldEtag is a InventoryOptionalField enum value+ InventoryOptionalFieldEtag = "ETag"++ // InventoryOptionalFieldIsMultipartUploaded is a InventoryOptionalField enum value+ InventoryOptionalFieldIsMultipartUploaded = "IsMultipartUploaded"++ // InventoryOptionalFieldReplicationStatus is a InventoryOptionalField enum value+ InventoryOptionalFieldReplicationStatus = "ReplicationStatus"++ // InventoryOptionalFieldEncryptionStatus is a InventoryOptionalField enum value+ InventoryOptionalFieldEncryptionStatus = "EncryptionStatus"++ // InventoryOptionalFieldObjectLockRetainUntilDate is a InventoryOptionalField enum value+ InventoryOptionalFieldObjectLockRetainUntilDate = "ObjectLockRetainUntilDate"++ // InventoryOptionalFieldObjectLockMode is a InventoryOptionalField enum value+ InventoryOptionalFieldObjectLockMode = "ObjectLockMode"++ // InventoryOptionalFieldObjectLockLegalHoldStatus is a InventoryOptionalField enum value+ InventoryOptionalFieldObjectLockLegalHoldStatus = "ObjectLockLegalHoldStatus"+)++const (+ // JSONTypeDocument is a JSONType enum value+ JSONTypeDocument = "DOCUMENT"++ // JSONTypeLines is a JSONType enum value+ JSONTypeLines = "LINES"+)++const (+ // MFADeleteEnabled is a MFADelete enum value+ MFADeleteEnabled = "Enabled"++ // MFADeleteDisabled is a MFADelete enum value+ MFADeleteDisabled = "Disabled"+)++const (+ // MFADeleteStatusEnabled is a MFADeleteStatus enum value+ MFADeleteStatusEnabled = "Enabled"++ // MFADeleteStatusDisabled is a MFADeleteStatus enum value+ MFADeleteStatusDisabled = "Disabled"+)++const (+ // MetadataDirectiveCopy is a MetadataDirective enum value+ MetadataDirectiveCopy = "COPY"++ // MetadataDirectiveReplace is a MetadataDirective enum value+ MetadataDirectiveReplace = "REPLACE"+)++const (+ // ObjectCannedACLPrivate is a ObjectCannedACL enum value+ ObjectCannedACLPrivate = "private"++ // ObjectCannedACLPublicRead is a ObjectCannedACL enum value+ ObjectCannedACLPublicRead = "public-read"++ // ObjectCannedACLPublicReadWrite is a ObjectCannedACL enum value+ ObjectCannedACLPublicReadWrite = "public-read-write"++ // ObjectCannedACLAuthenticatedRead is a ObjectCannedACL enum value+ ObjectCannedACLAuthenticatedRead = "authenticated-read"++ // ObjectCannedACLAwsExecRead is a ObjectCannedACL enum value+ ObjectCannedACLAwsExecRead = "aws-exec-read"++ // ObjectCannedACLBucketOwnerRead is a ObjectCannedACL enum value+ ObjectCannedACLBucketOwnerRead = "bucket-owner-read"++ // ObjectCannedACLBucketOwnerFullControl is a ObjectCannedACL enum value+ ObjectCannedACLBucketOwnerFullControl = "bucket-owner-full-control"+)++const (+ // ObjectLockEnabledEnabled is a ObjectLockEnabled enum value+ ObjectLockEnabledEnabled = "Enabled"+)++const (+ // ObjectLockLegalHoldStatusOn is a ObjectLockLegalHoldStatus enum value+ ObjectLockLegalHoldStatusOn = "ON"++ // ObjectLockLegalHoldStatusOff is a ObjectLockLegalHoldStatus enum value+ ObjectLockLegalHoldStatusOff = "OFF"+)++const (+ // ObjectLockModeGovernance is a ObjectLockMode enum value+ ObjectLockModeGovernance = "GOVERNANCE"++ // ObjectLockModeCompliance is a ObjectLockMode enum value+ ObjectLockModeCompliance = "COMPLIANCE"+)++const (+ // ObjectLockRetentionModeGovernance is a ObjectLockRetentionMode enum value+ ObjectLockRetentionModeGovernance = "GOVERNANCE"++ // ObjectLockRetentionModeCompliance is a ObjectLockRetentionMode enum value+ ObjectLockRetentionModeCompliance = "COMPLIANCE"+)++const (+ // ObjectStorageClassStandard is a ObjectStorageClass enum value+ ObjectStorageClassStandard = "STANDARD"++ // ObjectStorageClassReducedRedundancy is a ObjectStorageClass enum value+ ObjectStorageClassReducedRedundancy = "REDUCED_REDUNDANCY"++ // ObjectStorageClassGlacier is a ObjectStorageClass enum value+ ObjectStorageClassGlacier = "GLACIER"++ // ObjectStorageClassStandardIa is a ObjectStorageClass enum value+ ObjectStorageClassStandardIa = "STANDARD_IA"++ // ObjectStorageClassOnezoneIa is a ObjectStorageClass enum value+ ObjectStorageClassOnezoneIa = "ONEZONE_IA"++ // ObjectStorageClassIntelligentTiering is a ObjectStorageClass enum value+ ObjectStorageClassIntelligentTiering = "INTELLIGENT_TIERING"+)++const (+ // ObjectVersionStorageClassStandard is a ObjectVersionStorageClass enum value+ ObjectVersionStorageClassStandard = "STANDARD"+)++const (+ // OwnerOverrideDestination is a OwnerOverride enum value+ OwnerOverrideDestination = "Destination"+)++const (+ // PayerRequester is a Payer enum value+ PayerRequester = "Requester"++ // PayerBucketOwner is a Payer enum value+ PayerBucketOwner = "BucketOwner"+)++const (+ // PermissionFullControl is a Permission enum value+ PermissionFullControl = "FULL_CONTROL"++ // PermissionWrite is a Permission enum value+ PermissionWrite = "WRITE"++ // PermissionWriteAcp is a Permission enum value+ PermissionWriteAcp = "WRITE_ACP"++ // PermissionRead is a Permission enum value+ PermissionRead = "READ"++ // PermissionReadAcp is a Permission enum value+ PermissionReadAcp = "READ_ACP"+)++const (+ // ProtocolHttp is a Protocol enum value+ ProtocolHttp = "http"++ // ProtocolHttps is a Protocol enum value+ ProtocolHttps = "https"+)++const (+ // QuoteFieldsAlways is a QuoteFields enum value+ QuoteFieldsAlways = "ALWAYS"++ // QuoteFieldsAsneeded is a QuoteFields enum value+ QuoteFieldsAsneeded = "ASNEEDED"+)++const (+ // ReplicationRuleStatusEnabled is a ReplicationRuleStatus enum value+ ReplicationRuleStatusEnabled = "Enabled"++ // ReplicationRuleStatusDisabled is a ReplicationRuleStatus enum value+ ReplicationRuleStatusDisabled = "Disabled"+)++const (+ // ReplicationStatusComplete is a ReplicationStatus enum value+ ReplicationStatusComplete = "COMPLETE"++ // ReplicationStatusPending is a ReplicationStatus enum value+ ReplicationStatusPending = "PENDING"++ // ReplicationStatusFailed is a ReplicationStatus enum value+ ReplicationStatusFailed = "FAILED"++ // ReplicationStatusReplica is a ReplicationStatus enum value+ ReplicationStatusReplica = "REPLICA"+)++// If present, indicates that the requester was successfully charged for the+// request.+const (+ // RequestChargedRequester is a RequestCharged enum value+ RequestChargedRequester = "requester"+)++// 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+const (+ // RequestPayerRequester is a RequestPayer enum value+ RequestPayerRequester = "requester"+)++const (+ // RestoreRequestTypeSelect is a RestoreRequestType enum value+ RestoreRequestTypeSelect = "SELECT"+)++const (+ // ServerSideEncryptionAes256 is a ServerSideEncryption enum value+ ServerSideEncryptionAes256 = "AES256"++ // ServerSideEncryptionAwsKms is a ServerSideEncryption enum value+ ServerSideEncryptionAwsKms = "aws:kms"+)++const (+ // SseKmsEncryptedObjectsStatusEnabled is a SseKmsEncryptedObjectsStatus enum value+ SseKmsEncryptedObjectsStatusEnabled = "Enabled"++ // SseKmsEncryptedObjectsStatusDisabled is a SseKmsEncryptedObjectsStatus enum value+ SseKmsEncryptedObjectsStatusDisabled = "Disabled"+)++const (+ // StorageClassStandard is a StorageClass enum value+ StorageClassStandard = "STANDARD"++ // StorageClassReducedRedundancy is a StorageClass enum value+ StorageClassReducedRedundancy = "REDUCED_REDUNDANCY"++ // StorageClassStandardIa is a StorageClass enum value+ StorageClassStandardIa = "STANDARD_IA"++ // StorageClassOnezoneIa is a StorageClass enum value+ StorageClassOnezoneIa = "ONEZONE_IA"++ // StorageClassIntelligentTiering is a StorageClass enum value+ StorageClassIntelligentTiering = "INTELLIGENT_TIERING"++ // StorageClassGlacier is a StorageClass enum value+ StorageClassGlacier = "GLACIER"+)++const (+ // StorageClassAnalysisSchemaVersionV1 is a StorageClassAnalysisSchemaVersion enum value+ StorageClassAnalysisSchemaVersionV1 = "V_1"+)++const (+ // TaggingDirectiveCopy is a TaggingDirective enum value+ TaggingDirectiveCopy = "COPY"++ // TaggingDirectiveReplace is a TaggingDirective enum value+ TaggingDirectiveReplace = "REPLACE"+)++const (+ // TierStandard is a Tier enum value+ TierStandard = "Standard"++ // TierBulk is a Tier enum value+ TierBulk = "Bulk"++ // TierExpedited is a Tier enum value+ TierExpedited = "Expedited"+)++const (+ // TransitionStorageClassGlacier is a TransitionStorageClass enum value+ TransitionStorageClassGlacier = "GLACIER"++ // TransitionStorageClassStandardIa is a TransitionStorageClass enum value+ TransitionStorageClassStandardIa = "STANDARD_IA"++ // TransitionStorageClassOnezoneIa is a TransitionStorageClass enum value+ TransitionStorageClassOnezoneIa = "ONEZONE_IA"++ // TransitionStorageClassIntelligentTiering is a TransitionStorageClass enum value+ TransitionStorageClassIntelligentTiering = "INTELLIGENT_TIERING"+)++const (+ // TypeCanonicalUser is a Type enum value+ TypeCanonicalUser = "CanonicalUser"++ // TypeAmazonCustomerByEmail is a Type enum value+ TypeAmazonCustomerByEmail = "AmazonCustomerByEmail"++ // TypeGroup is a Type enum value+ TypeGroup = "Group"+)diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/body_hash.go b/vendor/github.com/aws/aws-sdk-go/service/s3/body_hash.gonew file mode 100644index 000000000..5c8ce5cc8--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/body_hash.go@@ -0,0 +1,249 @@+package s3++import (+ "bytes"+ "crypto/md5"+ "crypto/sha256"+ "encoding/base64"+ "encoding/hex"+ "fmt"+ "hash"+ "io"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/sdkio"+)++const (+ contentMD5Header = "Content-Md5"+ contentSha256Header = "X-Amz-Content-Sha256"+ amzTeHeader = "X-Amz-Te"+ amzTxEncodingHeader = "X-Amz-Transfer-Encoding"++ appendMD5TxEncoding = "append-md5"+)++// contentMD5 computes and sets the HTTP Content-MD5 header for requests that+// require it.+func contentMD5(r *request.Request) {+ h := md5.New()++ if !aws.IsReaderSeekable(r.Body) {+ if r.Config.Logger != nil {+ r.Config.Logger.Log(fmt.Sprintf(+ "Unable to compute Content-MD5 for unseekable body, S3.%s",+ r.Operation.Name))+ }+ return+ }++ if _, err := copySeekableBody(h, r.Body); err != nil {+ r.Error = awserr.New("ContentMD5", "failed to compute body MD5", err)+ return+ }++ // encode the md5 checksum in base64 and set the request header.+ v := base64.StdEncoding.EncodeToString(h.Sum(nil))+ r.HTTPRequest.Header.Set(contentMD5Header, v)+}++// computeBodyHashes will add Content MD5 and Content Sha256 hashes to the+// request. If the body is not seekable or S3DisableContentMD5Validation set+// this handler will be ignored.+func computeBodyHashes(r *request.Request) {+ if aws.BoolValue(r.Config.S3DisableContentMD5Validation) {+ return+ }+ if r.IsPresigned() {+ return+ }+ if r.Error != nil || !aws.IsReaderSeekable(r.Body) {+ return+ }++ var md5Hash, sha256Hash hash.Hash+ hashers := make([]io.Writer, 0, 2)++ // Determine upfront which hashes can be set without overriding user+ // provide header data.+ if v := r.HTTPRequest.Header.Get(contentMD5Header); len(v) == 0 {+ md5Hash = md5.New()+ hashers = append(hashers, md5Hash)+ }++ if v := r.HTTPRequest.Header.Get(contentSha256Header); len(v) == 0 {+ sha256Hash = sha256.New()+ hashers = append(hashers, sha256Hash)+ }++ // Create the destination writer based on the hashes that are not already+ // provided by the user.+ var dst io.Writer+ switch len(hashers) {+ case 0:+ return+ case 1:+ dst = hashers[0]+ default:+ dst = io.MultiWriter(hashers...)+ }++ if _, err := copySeekableBody(dst, r.Body); err != nil {+ r.Error = awserr.New("BodyHashError", "failed to compute body hashes", err)+ return+ }++ // For the hashes created, set the associated headers that the user did not+ // already provide.+ if md5Hash != nil {+ sum := make([]byte, md5.Size)+ encoded := make([]byte, md5Base64EncLen)++ base64.StdEncoding.Encode(encoded, md5Hash.Sum(sum[0:0]))+ r.HTTPRequest.Header[contentMD5Header] = []string{string(encoded)}+ }++ if sha256Hash != nil {+ encoded := make([]byte, sha256HexEncLen)+ sum := make([]byte, sha256.Size)++ hex.Encode(encoded, sha256Hash.Sum(sum[0:0]))+ r.HTTPRequest.Header[contentSha256Header] = []string{string(encoded)}+ }+}++const (+ md5Base64EncLen = (md5.Size + 2) / 3 * 4 // base64.StdEncoding.EncodedLen+ sha256HexEncLen = sha256.Size * 2 // hex.EncodedLen+)++func copySeekableBody(dst io.Writer, src io.ReadSeeker) (int64, error) {+ curPos, err := src.Seek(0, sdkio.SeekCurrent)+ if err != nil {+ return 0, err+ }++ // hash the body. seek back to the first position after reading to reset+ // the body for transmission. copy errors may be assumed to be from the+ // body.+ n, err := io.Copy(dst, src)+ if err != nil {+ return n, err+ }++ _, err = src.Seek(curPos, sdkio.SeekStart)+ if err != nil {+ return n, err+ }++ return n, nil+}++// Adds the x-amz-te: append_md5 header to the request. This requests the service+// responds with a trailing MD5 checksum.+//+// Will not ask for append MD5 if disabled, the request is presigned or,+// or the API operation does not support content MD5 validation.+func askForTxEncodingAppendMD5(r *request.Request) {+ if aws.BoolValue(r.Config.S3DisableContentMD5Validation) {+ return+ }+ if r.IsPresigned() {+ return+ }+ r.HTTPRequest.Header.Set(amzTeHeader, appendMD5TxEncoding)+}++func useMD5ValidationReader(r *request.Request) {+ if r.Error != nil {+ return+ }++ if v := r.HTTPResponse.Header.Get(amzTxEncodingHeader); v != appendMD5TxEncoding {+ return+ }++ var bodyReader *io.ReadCloser+ var contentLen int64+ switch tv := r.Data.(type) {+ case *GetObjectOutput:+ bodyReader = &tv.Body+ contentLen = aws.Int64Value(tv.ContentLength)+ // Update ContentLength hiden the trailing MD5 checksum.+ tv.ContentLength = aws.Int64(contentLen - md5.Size)+ tv.ContentRange = aws.String(r.HTTPResponse.Header.Get("X-Amz-Content-Range"))+ default:+ r.Error = awserr.New("ChecksumValidationError",+ fmt.Sprintf("%s: %s header received on unsupported API, %s",+ amzTxEncodingHeader, appendMD5TxEncoding, r.Operation.Name,+ ), nil)+ return+ }++ if contentLen < md5.Size {+ r.Error = awserr.New("ChecksumValidationError",+ fmt.Sprintf("invalid Content-Length %d for %s %s",+ contentLen, appendMD5TxEncoding, amzTxEncodingHeader,+ ), nil)+ return+ }++ // Wrap and swap the response body reader with the validation reader.+ *bodyReader = newMD5ValidationReader(*bodyReader, contentLen-md5.Size)+}++type md5ValidationReader struct {+ rawReader io.ReadCloser+ payload io.Reader+ hash hash.Hash++ payloadLen int64+ read int64+}++func newMD5ValidationReader(reader io.ReadCloser, payloadLen int64) *md5ValidationReader {+ h := md5.New()+ return &md5ValidationReader{+ rawReader: reader,+ payload: io.TeeReader(&io.LimitedReader{R: reader, N: payloadLen}, h),+ hash: h,+ payloadLen: payloadLen,+ }+}++func (v *md5ValidationReader) Read(p []byte) (n int, err error) {+ n, err = v.payload.Read(p)+ if err != nil && err != io.EOF {+ return n, err+ }++ v.read += int64(n)++ if err == io.EOF {+ if v.read != v.payloadLen {+ return n, io.ErrUnexpectedEOF+ }+ expectSum := make([]byte, md5.Size)+ actualSum := make([]byte, md5.Size)+ if _, sumReadErr := io.ReadFull(v.rawReader, expectSum); sumReadErr != nil {+ return n, sumReadErr+ }+ actualSum = v.hash.Sum(actualSum[0:0])+ if !bytes.Equal(expectSum, actualSum) {+ return n, awserr.New("InvalidChecksum",+ fmt.Sprintf("expected MD5 checksum %s, got %s",+ hex.EncodeToString(expectSum),+ hex.EncodeToString(actualSum),+ ),+ nil)+ }+ }++ return n, err+}++func (v *md5ValidationReader) Close() error {+ return v.rawReader.Close()+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.go b/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.gonew file mode 100644index 000000000..bc68a46ac--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/bucket_location.go@@ -0,0 +1,106 @@+package s3++import (+ "io/ioutil"+ "regexp"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/awsutil"+ "github.com/aws/aws-sdk-go/aws/request"+)++var reBucketLocation = regexp.MustCompile(`>([^<>]+)<\/Location`)++// NormalizeBucketLocation is a utility function which will update the+// passed in value to always be a region ID. Generally this would be used+// with GetBucketLocation API operation.+//+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".+//+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html+// for more information on the values that can be returned.+func NormalizeBucketLocation(loc string) string {+ switch loc {+ case "":+ loc = "us-east-1"+ case "EU":+ loc = "eu-west-1"+ }++ return loc+}++// NormalizeBucketLocationHandler is a request handler which will update the+// GetBucketLocation's result LocationConstraint value to always be a region ID.+//+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".+//+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html+// for more information on the values that can be returned.+//+// req, result := svc.GetBucketLocationRequest(&s3.GetBucketLocationInput{+// Bucket: aws.String(bucket),+// })+// req.Handlers.Unmarshal.PushBackNamed(NormalizeBucketLocationHandler)+// err := req.Send()+var NormalizeBucketLocationHandler = request.NamedHandler{+ Name: "awssdk.s3.NormalizeBucketLocation",+ Fn: func(req *request.Request) {+ if req.Error != nil {+ return+ }++ out := req.Data.(*GetBucketLocationOutput)+ loc := NormalizeBucketLocation(aws.StringValue(out.LocationConstraint))+ out.LocationConstraint = aws.String(loc)+ },+}++// WithNormalizeBucketLocation is a request option which will update the+// GetBucketLocation's result LocationConstraint value to always be a region ID.+//+// Replaces empty string with "us-east-1", and "EU" with "eu-west-1".+//+// See http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlocation.html+// for more information on the values that can be returned.+//+// result, err := svc.GetBucketLocationWithContext(ctx,+// &s3.GetBucketLocationInput{+// Bucket: aws.String(bucket),+// },+// s3.WithNormalizeBucketLocation,+// )+func WithNormalizeBucketLocation(r *request.Request) {+ r.Handlers.Unmarshal.PushBackNamed(NormalizeBucketLocationHandler)+}++func buildGetBucketLocation(r *request.Request) {+ if r.DataFilled() {+ out := r.Data.(*GetBucketLocationOutput)+ b, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.New("SerializationError", "failed reading response body", err)+ return+ }++ match := reBucketLocation.FindSubmatch(b)+ if len(match) > 1 {+ loc := string(match[1])+ out.LocationConstraint = aws.String(loc)+ }+ }+}++func populateLocationConstraint(r *request.Request) {+ if r.ParamsFilled() && aws.StringValue(r.Config.Region) != "us-east-1" {+ in := r.Params.(*CreateBucketInput)+ if in.CreateBucketConfiguration == nil {+ r.Params = awsutil.CopyOf(r.Params)+ in = r.Params.(*CreateBucketInput)+ in.CreateBucketConfiguration = &CreateBucketConfiguration{+ LocationConstraint: r.Config.Region,+ }+ }+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.go b/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.gonew file mode 100644index 000000000..95f245636--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/customizations.go@@ -0,0 +1,74 @@+package s3++import (+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/s3err"+)++func init() {+ initClient = defaultInitClientFn+ initRequest = defaultInitRequestFn+}++func defaultInitClientFn(c *client.Client) {+ // Support building custom endpoints based on config+ c.Handlers.Build.PushFront(updateEndpointForS3Config)++ // Require SSL when using SSE keys+ c.Handlers.Validate.PushBack(validateSSERequiresSSL)+ c.Handlers.Build.PushBack(computeSSEKeys)++ // S3 uses custom error unmarshaling logic+ c.Handlers.UnmarshalError.Clear()+ c.Handlers.UnmarshalError.PushBack(unmarshalError)+ c.Handlers.UnmarshalError.PushBackNamed(s3err.RequestFailureWrapperHandler())+}++func defaultInitRequestFn(r *request.Request) {+ // Add reuest handlers for specific platforms.+ // e.g. 100-continue support for PUT requests using Go 1.6+ platformRequestHandlers(r)++ switch r.Operation.Name {+ case opPutBucketCors, opPutBucketLifecycle, opPutBucketPolicy,+ opPutBucketTagging, opDeleteObjects, opPutBucketLifecycleConfiguration,+ opPutObjectLegalHold, opPutObjectRetention, opPutObjectLockConfiguration,+ opPutBucketReplication:+ // These S3 operations require Content-MD5 to be set+ r.Handlers.Build.PushBack(contentMD5)+ case opGetBucketLocation:+ // GetBucketLocation has custom parsing logic+ r.Handlers.Unmarshal.PushFront(buildGetBucketLocation)+ case opCreateBucket:+ // Auto-populate LocationConstraint with current region+ r.Handlers.Validate.PushFront(populateLocationConstraint)+ case opCopyObject, opUploadPartCopy, opCompleteMultipartUpload:+ r.Handlers.Unmarshal.PushFront(copyMultipartStatusOKUnmarhsalError)+ r.Handlers.Unmarshal.PushBackNamed(s3err.RequestFailureWrapperHandler())+ case opPutObject, opUploadPart:+ r.Handlers.Build.PushBack(computeBodyHashes)+ // Disabled until #1837 root issue is resolved.+ // case opGetObject:+ // r.Handlers.Build.PushBack(askForTxEncodingAppendMD5)+ // r.Handlers.Unmarshal.PushBack(useMD5ValidationReader)+ }+}++// bucketGetter is an accessor interface to grab the "Bucket" field from+// an S3 type.+type bucketGetter interface {+ getBucket() string+}++// sseCustomerKeyGetter is an accessor interface to grab the "SSECustomerKey"+// field from an S3 type.+type sseCustomerKeyGetter interface {+ getSSECustomerKey() string+}++// copySourceSSECustomerKeyGetter is an accessor interface to grab the+// "CopySourceSSECustomerKey" field from an S3 type.+type copySourceSSECustomerKeyGetter interface {+ getCopySourceSSECustomerKey() string+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/doc.go b/vendor/github.com/aws/aws-sdk-go/service/s3/doc.gonew file mode 100644index 000000000..0def02255--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/doc.go@@ -0,0 +1,26 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++// Package s3 provides the client and types for making API+// requests to Amazon Simple Storage Service.+//+// See https://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01 for more information on this service.+//+// See s3 package documentation for more information.+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/+//+// Using the Client+//+// To contact Amazon Simple Storage Service with the SDK use the New function to create+// a new service client. With that client you can make API requests to the service.+// These clients are safe to use concurrently.+//+// See the SDK's documentation for more information on how to use the SDK.+// https://docs.aws.amazon.com/sdk-for-go/api/+//+// See aws.Config documentation for more information on configuring SDK clients.+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config+//+// See the Amazon Simple Storage Service client S3 for more+// information on creating client for this service.+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/#New+package s3diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go b/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.gonew file mode 100644index 000000000..39b912c26--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/doc_custom.go@@ -0,0 +1,109 @@+// Upload Managers+//+// The s3manager package's Uploader provides concurrent upload of content to S3+// by taking advantage of S3's Multipart APIs. The Uploader also supports both+// io.Reader for streaming uploads, and will also take advantage of io.ReadSeeker+// for optimizations if the Body satisfies that type. Once the Uploader instance+// is created you can call Upload concurrently from multiple goroutines safely.+//+// // The session the S3 Uploader will use+// sess := session.Must(session.NewSession())+//+// // Create an uploader with the session and default options+// uploader := s3manager.NewUploader(sess)+//+// f, err := os.Open(filename)+// if err != nil {+// return fmt.Errorf("failed to open file %q, %v", filename, err)+// }+//+// // Upload the file to S3.+// result, err := uploader.Upload(&s3manager.UploadInput{+// Bucket: aws.String(myBucket),+// Key: aws.String(myString),+// Body: f,+// })+// if err != nil {+// return fmt.Errorf("failed to upload file, %v", err)+// }+// fmt.Printf("file uploaded to, %s\n", aws.StringValue(result.Location))+//+// See the s3manager package's Uploader type documentation for more information.+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#Uploader+//+// Download Manager+//+// The s3manager package's Downloader provides concurrently downloading of Objects+// from S3. The Downloader will write S3 Object content with an io.WriterAt.+// Once the Downloader instance is created you can call Download concurrently from+// multiple goroutines safely.+//+// // The session the S3 Downloader will use+// sess := session.Must(session.NewSession())+//+// // Create a downloader with the session and default options+// downloader := s3manager.NewDownloader(sess)+//+// // Create a file to write the S3 Object contents to.+// f, err := os.Create(filename)+// if err != nil {+// return fmt.Errorf("failed to create file %q, %v", filename, err)+// }+//+// // Write the contents of S3 Object to the file+// n, err := downloader.Download(f, &s3.GetObjectInput{+// Bucket: aws.String(myBucket),+// Key: aws.String(myString),+// })+// if err != nil {+// return fmt.Errorf("failed to download file, %v", err)+// }+// fmt.Printf("file downloaded, %d bytes\n", n)+//+// See the s3manager package's Downloader type documentation for more information.+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#Downloader+//+// Get Bucket Region+//+// GetBucketRegion will attempt to get the region for a bucket using a region+// hint to determine which AWS partition to perform the query on. Use this utility+// to determine the region a bucket is in.+//+// sess := session.Must(session.NewSession())+//+// bucket := "my-bucket"+// region, err := s3manager.GetBucketRegion(ctx, sess, bucket, "us-west-2")+// if err != nil {+// if aerr, ok := err.(awserr.Error); ok && aerr.Code() == "NotFound" {+// fmt.Fprintf(os.Stderr, "unable to find bucket %s's region not found\n", bucket)+// }+// return err+// }+// fmt.Printf("Bucket %s is in %s region\n", bucket, region)+//+// See the s3manager package's GetBucketRegion function documentation for more information+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3manager/#GetBucketRegion+//+// S3 Crypto Client+//+// The s3crypto package provides the tools to upload and download encrypted+// content from S3. The Encryption and Decryption clients can be used concurrently+// once the client is created.+//+// sess := session.Must(session.NewSession())+//+// // Create the decryption client.+// svc := s3crypto.NewDecryptionClient(sess)+//+// // The object will be downloaded from S3 and decrypted locally. By metadata+// // about the object's encryption will instruct the decryption client how+// // decrypt the content of the object. By default KMS is used for keys.+// result, err := svc.GetObject(&s3.GetObjectInput {+// Bucket: aws.String(myBucket),+// Key: aws.String(myKey),+// })+//+// See the s3crypto package documentation for more information.+// https://docs.aws.amazon.com/sdk-for-go/api/service/s3/s3crypto/+//+package s3diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/errors.go b/vendor/github.com/aws/aws-sdk-go/service/s3/errors.gonew file mode 100644index 000000000..931cb17bb--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/errors.go@@ -0,0 +1,48 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package s3++const (++ // ErrCodeBucketAlreadyExists for service response error code+ // "BucketAlreadyExists".+ //+ // The requested bucket name is not available. The bucket namespace is shared+ // by all users of the system. Please select a different name and try again.+ ErrCodeBucketAlreadyExists = "BucketAlreadyExists"++ // ErrCodeBucketAlreadyOwnedByYou for service response error code+ // "BucketAlreadyOwnedByYou".+ ErrCodeBucketAlreadyOwnedByYou = "BucketAlreadyOwnedByYou"++ // ErrCodeNoSuchBucket for service response error code+ // "NoSuchBucket".+ //+ // The specified bucket does not exist.+ ErrCodeNoSuchBucket = "NoSuchBucket"++ // ErrCodeNoSuchKey for service response error code+ // "NoSuchKey".+ //+ // The specified key does not exist.+ ErrCodeNoSuchKey = "NoSuchKey"++ // ErrCodeNoSuchUpload for service response error code+ // "NoSuchUpload".+ //+ // The specified multipart upload does not exist.+ ErrCodeNoSuchUpload = "NoSuchUpload"++ // ErrCodeObjectAlreadyInActiveTierError for service response error code+ // "ObjectAlreadyInActiveTierError".+ //+ // This operation is not allowed against this storage tier+ ErrCodeObjectAlreadyInActiveTierError = "ObjectAlreadyInActiveTierError"++ // ErrCodeObjectNotInActiveTierError for service response error code+ // "ObjectNotInActiveTierError".+ //+ // The source object of the COPY operation is not in the active tier and is+ // only stored in Amazon Glacier.+ ErrCodeObjectNotInActiveTierError = "ObjectNotInActiveTierError"+)diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go b/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.gonew file mode 100644index 000000000..a7fbc2de2--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go@@ -0,0 +1,155 @@+package s3++import (+ "fmt"+ "net/url"+ "regexp"+ "strings"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++// an operationBlacklist is a list of operation names that should a+// request handler should not be executed with.+type operationBlacklist []string++// Continue will return true of the Request's operation name is not+// in the blacklist. False otherwise.+func (b operationBlacklist) Continue(r *request.Request) bool {+ for i := 0; i < len(b); i++ {+ if b[i] == r.Operation.Name {+ return false+ }+ }+ return true+}++var accelerateOpBlacklist = operationBlacklist{+ opListBuckets, opCreateBucket, opDeleteBucket,+}++// Request handler to automatically add the bucket name to the endpoint domain+// if possible. This style of bucket is valid for all bucket names which are+// DNS compatible and do not contain "."+func updateEndpointForS3Config(r *request.Request) {+ forceHostStyle := aws.BoolValue(r.Config.S3ForcePathStyle)+ accelerate := aws.BoolValue(r.Config.S3UseAccelerate)++ if accelerate && accelerateOpBlacklist.Continue(r) {+ if forceHostStyle {+ if r.Config.Logger != nil {+ r.Config.Logger.Log("ERROR: aws.Config.S3UseAccelerate is not compatible with aws.Config.S3ForcePathStyle, ignoring S3ForcePathStyle.")+ }+ }+ updateEndpointForAccelerate(r)+ } else if !forceHostStyle && r.Operation.Name != opGetBucketLocation {+ updateEndpointForHostStyle(r)+ }+}++func updateEndpointForHostStyle(r *request.Request) {+ bucket, ok := bucketNameFromReqParams(r.Params)+ if !ok {+ // Ignore operation requests if the bucketname was not provided+ // if this is an input validation error the validation handler+ // will report it.+ return+ }++ if !hostCompatibleBucketName(r.HTTPRequest.URL, bucket) {+ // bucket name must be valid to put into the host+ return+ }++ moveBucketToHost(r.HTTPRequest.URL, bucket)+}++var (+ accelElem = []byte("s3-accelerate.dualstack.")+)++func updateEndpointForAccelerate(r *request.Request) {+ bucket, ok := bucketNameFromReqParams(r.Params)+ if !ok {+ // Ignore operation requests if the bucketname was not provided+ // if this is an input validation error the validation handler+ // will report it.+ return+ }++ if !hostCompatibleBucketName(r.HTTPRequest.URL, bucket) {+ r.Error = awserr.New("InvalidParameterException",+ fmt.Sprintf("bucket name %s is not compatible with S3 Accelerate", bucket),+ nil)+ return+ }++ parts := strings.Split(r.HTTPRequest.URL.Host, ".")+ if len(parts) < 3 {+ r.Error = awserr.New("InvalidParameterExecption",+ fmt.Sprintf("unable to update endpoint host for S3 accelerate, hostname invalid, %s",+ r.HTTPRequest.URL.Host), nil)+ return+ }++ if parts[0] == "s3" || strings.HasPrefix(parts[0], "s3-") {+ parts[0] = "s3-accelerate"+ }+ for i := 1; i+1 < len(parts); i++ {+ if parts[i] == aws.StringValue(r.Config.Region) {+ parts = append(parts[:i], parts[i+1:]...)+ break+ }+ }++ r.HTTPRequest.URL.Host = strings.Join(parts, ".")++ moveBucketToHost(r.HTTPRequest.URL, bucket)+}++// Attempts to retrieve the bucket name from the request input parameters.+// If no bucket is found, or the field is empty "", false will be returned.+func bucketNameFromReqParams(params interface{}) (string, bool) {+ if iface, ok := params.(bucketGetter); ok {+ b := iface.getBucket()+ return b, len(b) > 0+ }++ return "", false+}++// hostCompatibleBucketName returns true if the request should+// put the bucket in the host. This is false if S3ForcePathStyle is+// explicitly set or if the bucket is not DNS compatible.+func hostCompatibleBucketName(u *url.URL, bucket string) bool {+ // Bucket might be DNS compatible but dots in the hostname will fail+ // certificate validation, so do not use host-style.+ if u.Scheme == "https" && strings.Contains(bucket, ".") {+ return false+ }++ // if the bucket is DNS compatible+ return dnsCompatibleBucketName(bucket)+}++var reDomain = regexp.MustCompile(`^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$`)+var reIPAddress = regexp.MustCompile(`^(\d+\.){3}\d+$`)++// dnsCompatibleBucketName returns true if the bucket name is DNS compatible.+// Buckets created outside of the classic region MUST be DNS compatible.+func dnsCompatibleBucketName(bucket string) bool {+ return reDomain.MatchString(bucket) &&+ !reIPAddress.MatchString(bucket) &&+ !strings.Contains(bucket, "..")+}++// moveBucketToHost moves the bucket name from the URI path to URL host.+func moveBucketToHost(u *url.URL, bucket string) {+ u.Host = bucket + "." + u.Host+ u.Path = strings.Replace(u.Path, "/{Bucket}", "", -1)+ if u.Path == "" {+ u.Path = "/"+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.gonew file mode 100644index 000000000..8e6f3307d--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go@@ -0,0 +1,8 @@+// +build !go1.6++package s3++import "github.com/aws/aws-sdk-go/aws/request"++func platformRequestHandlers(r *request.Request) {+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.gonew file mode 100644index 000000000..14d05f7b7--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go@@ -0,0 +1,28 @@+// +build go1.6++package s3++import (+ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/request"+)++func platformRequestHandlers(r *request.Request) {+ if r.Operation.HTTPMethod == "PUT" {+ // 100-Continue should only be used on put requests.+ r.Handlers.Sign.PushBack(add100Continue)+ }+}++func add100Continue(r *request.Request) {+ if aws.BoolValue(r.Config.S3Disable100Continue) {+ return+ }+ if r.HTTPRequest.ContentLength < 1024*1024*2 {+ // Ignore requests smaller than 2MB. This helps prevent delaying+ // requests unnecessarily.+ return+ }++ r.HTTPRequest.Header.Set("Expect", "100-Continue")+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/service.go b/vendor/github.com/aws/aws-sdk-go/service/s3/service.gonew file mode 100644index 000000000..d17dcc9da--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/service.go@@ -0,0 +1,99 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package s3++import (+ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/aws/signer/v4"+ "github.com/aws/aws-sdk-go/private/protocol/restxml"+)++// S3 provides the API operation methods for making requests to+// Amazon Simple Storage Service. See this package's package overview docs+// for details on the service.+//+// S3 methods are safe to use concurrently. It is not safe to+// modify mutate any of the struct's properties though.+type S3 struct {+ *client.Client+}++// Used for custom client initialization logic+var initClient func(*client.Client)++// Used for custom request initialization logic+var initRequest func(*request.Request)++// Service information constants+const (+ ServiceName = "s3" // Name of service.+ EndpointsID = ServiceName // ID to lookup a service endpoint with.+ ServiceID = "S3" // ServiceID is a unique identifer of a specific service.+)++// New creates a new instance of the S3 client with a session.+// If additional configuration is needed for the client instance use the optional+// aws.Config parameter to add your extra config.+//+// Example:+// // Create a S3 client from just a session.+// svc := s3.New(mySession)+//+// // Create a S3 client with additional configuration+// svc := s3.New(mySession, aws.NewConfig().WithRegion("us-west-2"))+func New(p client.ConfigProvider, cfgs ...*aws.Config) *S3 {+ c := p.ClientConfig(EndpointsID, cfgs...)+ return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName)+}++// newClient creates, initializes and returns a new service client instance.+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *S3 {+ svc := &S3{+ Client: client.New(+ cfg,+ metadata.ClientInfo{+ ServiceName: ServiceName,+ ServiceID: ServiceID,+ SigningName: signingName,+ SigningRegion: signingRegion,+ Endpoint: endpoint,+ APIVersion: "2006-03-01",+ },+ handlers,+ ),+ }++ // Handlers+ svc.Handlers.Sign.PushBackNamed(v4.BuildNamedHandler(v4.SignRequestHandler.Name, func(s *v4.Signer) {+ s.DisableURIPathEscaping = true+ }))+ svc.Handlers.Build.PushBackNamed(restxml.BuildHandler)+ svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler)+ svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler)+ svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler)++ svc.Handlers.UnmarshalStream.PushBackNamed(restxml.UnmarshalHandler)++ // Run custom client initialization if present+ if initClient != nil {+ initClient(svc.Client)+ }++ return svc+}++// newRequest creates a new request for a S3 operation and runs any+// custom request initialization.+func (c *S3) newRequest(op *request.Operation, params, data interface{}) *request.Request {+ req := c.NewRequest(op, params, data)++ // Run custom request initialization if present+ if initRequest != nil {+ initRequest(req)+ }++ return req+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/sse.go b/vendor/github.com/aws/aws-sdk-go/service/s3/sse.gonew file mode 100644index 000000000..8010c4fa1--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/sse.go@@ -0,0 +1,54 @@+package s3++import (+ "crypto/md5"+ "encoding/base64"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++var errSSERequiresSSL = awserr.New("ConfigError", "cannot send SSE keys over HTTP.", nil)++func validateSSERequiresSSL(r *request.Request) {+ if r.HTTPRequest.URL.Scheme == "https" {+ return+ }++ if iface, ok := r.Params.(sseCustomerKeyGetter); ok {+ if len(iface.getSSECustomerKey()) > 0 {+ r.Error = errSSERequiresSSL+ return+ }+ }++ if iface, ok := r.Params.(copySourceSSECustomerKeyGetter); ok {+ if len(iface.getCopySourceSSECustomerKey()) > 0 {+ r.Error = errSSERequiresSSL+ return+ }+ }+}++func computeSSEKeys(r *request.Request) {+ headers := []string{+ "x-amz-server-side-encryption-customer-key",+ "x-amz-copy-source-server-side-encryption-customer-key",+ }++ for _, h := range headers {+ md5h := h + "-md5"+ if key := r.HTTPRequest.Header.Get(h); key != "" {+ // Base64-encode the value+ b64v := base64.StdEncoding.EncodeToString([]byte(key))+ r.HTTPRequest.Header.Set(h, b64v)++ // Add MD5 if it wasn't computed+ if r.HTTPRequest.Header.Get(md5h) == "" {+ sum := md5.Sum([]byte(key))+ b64sum := base64.StdEncoding.EncodeToString(sum[:])+ r.HTTPRequest.Header.Set(md5h, b64sum)+ }+ }+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.go b/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.gonew file mode 100644index 000000000..fde3050f9--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/statusok_error.go@@ -0,0 +1,40 @@+package s3++import (+ "bytes"+ "io/ioutil"+ "net/http"++ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/internal/sdkio"+)++func copyMultipartStatusOKUnmarhsalError(r *request.Request) {+ b, err := ioutil.ReadAll(r.HTTPResponse.Body)+ if err != nil {+ r.Error = awserr.NewRequestFailure(+ awserr.New("SerializationError", "unable to read response body", err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }+ body := bytes.NewReader(b)+ r.HTTPResponse.Body = ioutil.NopCloser(body)+ defer body.Seek(0, sdkio.SeekStart)++ if body.Len() == 0 {+ // If there is no body don't attempt to parse the body.+ return+ }++ unmarshalError(r)+ if err, ok := r.Error.(awserr.Error); ok && err != nil {+ if err.Code() == "SerializationError" {+ r.Error = nil+ return+ }+ r.HTTPResponse.StatusCode = http.StatusServiceUnavailable+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.gonew file mode 100644index 000000000..12c0612c8--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go@@ -0,0 +1,77 @@+package s3++import (+ "encoding/xml"+ "fmt"+ "io"+ "io/ioutil"+ "net/http"+ "strings"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awserr"+ "github.com/aws/aws-sdk-go/aws/request"+)++type xmlErrorResponse struct {+ XMLName xml.Name `xml:"Error"`+ Code string `xml:"Code"`+ Message string `xml:"Message"`+}++func unmarshalError(r *request.Request) {+ defer r.HTTPResponse.Body.Close()+ defer io.Copy(ioutil.Discard, r.HTTPResponse.Body)++ // Bucket exists in a different region, and request needs+ // to be made to the correct region.+ if r.HTTPResponse.StatusCode == http.StatusMovedPermanently {+ r.Error = awserr.NewRequestFailure(+ awserr.New("BucketRegionError",+ fmt.Sprintf("incorrect region, the bucket is not in '%s' region",+ aws.StringValue(r.Config.Region)),+ nil),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+ return+ }++ var errCode, errMsg string++ // Attempt to parse error from body if it is known+ resp := &xmlErrorResponse{}+ err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)+ if err != nil && err != io.EOF {+ errCode = "SerializationError"+ errMsg = "failed to decode S3 XML error response"+ } else {+ errCode = resp.Code+ errMsg = resp.Message+ err = nil+ }++ // Fallback to status code converted to message if still no error code+ if len(errCode) == 0 {+ statusText := http.StatusText(r.HTTPResponse.StatusCode)+ errCode = strings.Replace(statusText, " ", "", -1)+ errMsg = statusText+ }++ r.Error = awserr.NewRequestFailure(+ awserr.New(errCode, errMsg, err),+ r.HTTPResponse.StatusCode,+ r.RequestID,+ )+}++// A RequestFailure provides access to the S3 Request ID and Host ID values+// returned from API operation errors. Getting the error as a string will+// return the formated error with the same information as awserr.RequestFailure,+// while also adding the HostID value from the response.+type RequestFailure interface {+ awserr.RequestFailure++ // Host ID is the S3 Host ID needed for debug, and contacting support+ HostID() string+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.go b/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.gonew file mode 100644index 000000000..2596c694b--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/s3/waiters.go@@ -0,0 +1,214 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package s3++import (+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/request"+)++// WaitUntilBucketExists uses the Amazon S3 API operation+// HeadBucket to wait for a condition to be met before returning.+// If the condition is not met within the max attempt window, an error will+// be returned.+func (c *S3) WaitUntilBucketExists(input *HeadBucketInput) error {+ return c.WaitUntilBucketExistsWithContext(aws.BackgroundContext(), input)+}++// WaitUntilBucketExistsWithContext is an extended version of WaitUntilBucketExists.+// With the support for passing in a context and options to configure the+// Waiter and the underlying request options.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) WaitUntilBucketExistsWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.WaiterOption) error {+ w := request.Waiter{+ Name: "WaitUntilBucketExists",+ MaxAttempts: 20,+ Delay: request.ConstantWaiterDelay(5 * time.Second),+ Acceptors: []request.WaiterAcceptor{+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 200,+ },+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 301,+ },+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 403,+ },+ {+ State: request.RetryWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 404,+ },+ },+ Logger: c.Config.Logger,+ NewRequest: func(opts []request.Option) (*request.Request, error) {+ var inCpy *HeadBucketInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.HeadBucketRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }+ w.ApplyOptions(opts...)++ return w.WaitWithContext(ctx)+}++// WaitUntilBucketNotExists uses the Amazon S3 API operation+// HeadBucket to wait for a condition to be met before returning.+// If the condition is not met within the max attempt window, an error will+// be returned.+func (c *S3) WaitUntilBucketNotExists(input *HeadBucketInput) error {+ return c.WaitUntilBucketNotExistsWithContext(aws.BackgroundContext(), input)+}++// WaitUntilBucketNotExistsWithContext is an extended version of WaitUntilBucketNotExists.+// With the support for passing in a context and options to configure the+// Waiter and the underlying request options.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) WaitUntilBucketNotExistsWithContext(ctx aws.Context, input *HeadBucketInput, opts ...request.WaiterOption) error {+ w := request.Waiter{+ Name: "WaitUntilBucketNotExists",+ MaxAttempts: 20,+ Delay: request.ConstantWaiterDelay(5 * time.Second),+ Acceptors: []request.WaiterAcceptor{+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 404,+ },+ },+ Logger: c.Config.Logger,+ NewRequest: func(opts []request.Option) (*request.Request, error) {+ var inCpy *HeadBucketInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.HeadBucketRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }+ w.ApplyOptions(opts...)++ return w.WaitWithContext(ctx)+}++// WaitUntilObjectExists uses the Amazon S3 API operation+// HeadObject to wait for a condition to be met before returning.+// If the condition is not met within the max attempt window, an error will+// be returned.+func (c *S3) WaitUntilObjectExists(input *HeadObjectInput) error {+ return c.WaitUntilObjectExistsWithContext(aws.BackgroundContext(), input)+}++// WaitUntilObjectExistsWithContext is an extended version of WaitUntilObjectExists.+// With the support for passing in a context and options to configure the+// Waiter and the underlying request options.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) WaitUntilObjectExistsWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.WaiterOption) error {+ w := request.Waiter{+ Name: "WaitUntilObjectExists",+ MaxAttempts: 20,+ Delay: request.ConstantWaiterDelay(5 * time.Second),+ Acceptors: []request.WaiterAcceptor{+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 200,+ },+ {+ State: request.RetryWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 404,+ },+ },+ Logger: c.Config.Logger,+ NewRequest: func(opts []request.Option) (*request.Request, error) {+ var inCpy *HeadObjectInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.HeadObjectRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }+ w.ApplyOptions(opts...)++ return w.WaitWithContext(ctx)+}++// WaitUntilObjectNotExists uses the Amazon S3 API operation+// HeadObject to wait for a condition to be met before returning.+// If the condition is not met within the max attempt window, an error will+// be returned.+func (c *S3) WaitUntilObjectNotExists(input *HeadObjectInput) error {+ return c.WaitUntilObjectNotExistsWithContext(aws.BackgroundContext(), input)+}++// WaitUntilObjectNotExistsWithContext is an extended version of WaitUntilObjectNotExists.+// With the support for passing in a context and options to configure the+// Waiter and the underlying request options.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *S3) WaitUntilObjectNotExistsWithContext(ctx aws.Context, input *HeadObjectInput, opts ...request.WaiterOption) error {+ w := request.Waiter{+ Name: "WaitUntilObjectNotExists",+ MaxAttempts: 20,+ Delay: request.ConstantWaiterDelay(5 * time.Second),+ Acceptors: []request.WaiterAcceptor{+ {+ State: request.SuccessWaiterState,+ Matcher: request.StatusWaiterMatch,+ Expected: 404,+ },+ },+ Logger: c.Config.Logger,+ NewRequest: func(opts []request.Option) (*request.Request, error) {+ var inCpy *HeadObjectInput+ if input != nil {+ tmp := *input+ inCpy = &tmp+ }+ req, _ := c.HeadObjectRequest(inCpy)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return req, nil+ },+ }+ w.ApplyOptions(opts...)++ return w.WaitWithContext(ctx)+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/api.go b/vendor/github.com/aws/aws-sdk-go/service/sts/api.gonew file mode 100644index 000000000..ee908f916--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/api.go@@ -0,0 +1,2398 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package sts++import (+ "time"++ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/awsutil"+ "github.com/aws/aws-sdk-go/aws/request"+)++const opAssumeRole = "AssumeRole"++// AssumeRoleRequest generates a "aws/request.Request" representing the+// client's request for the AssumeRole operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See AssumeRole for more information on using the AssumeRole+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the AssumeRoleRequest method.+// req, resp := client.AssumeRoleRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRole+func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, output *AssumeRoleOutput) {+ op := &request.Operation{+ Name: opAssumeRole,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &AssumeRoleInput{}+ }++ output = &AssumeRoleOutput{}+ req = c.newRequest(op, input, output)+ return+}++// AssumeRole API operation for AWS Security Token Service.+//+// Returns a set of temporary security credentials (consisting of an access+// key ID, a secret access key, and a security token) that you can use to access+// AWS resources that you might not normally have access to. Typically, you+// use AssumeRole for cross-account access or federation. For a comparison of+// AssumeRole with the other APIs that produce temporary credentials, see Requesting+// Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)+// in the IAM User Guide.+//+// Important: You cannot call AssumeRole by using AWS root account credentials;+// access is denied. You must use credentials for an IAM user or an IAM role+// to call AssumeRole.+//+// For cross-account access, imagine that you own multiple accounts and need+// to access resources in each account. You could create long-term credentials+// in each account to access those resources. However, managing all those credentials+// and remembering which one can access which account can be time consuming.+// Instead, you can create one set of long-term credentials in one account and+// then use temporary security credentials to access all the other accounts+// by assuming roles in those accounts. For more information about roles, see+// IAM Roles (Delegation and Federation) (http://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html)+// in the IAM User Guide.+//+// For federation, you can, for example, grant single sign-on access to the+// AWS Management Console. If you already have an identity and authentication+// system in your corporate network, you don't have to recreate user identities+// in AWS in order to grant those user identities access to AWS. Instead, after+// a user has been authenticated, you call AssumeRole (and specify the role+// with the appropriate permissions) to get temporary security credentials for+// that user. With those temporary security credentials, you construct a sign-in+// URL that users can use to access the console. For more information, see Common+// Scenarios for Temporary Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html#sts-introduction)+// in the IAM User Guide.+//+// By default, the temporary security credentials created by AssumeRole last+// for one hour. However, you can use the optional DurationSeconds parameter+// to specify the duration of your session. You can provide a value from 900+// seconds (15 minutes) up to the maximum session duration setting for the role.+// This setting can have a value from 1 hour to 12 hours. To learn how to view+// the maximum value for your role, see View the Maximum Session Duration Setting+// for a Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+// in the IAM User Guide. The maximum session duration limit applies when you+// use the AssumeRole* API operations or the assume-role* CLI operations but+// does not apply when you use those operations to create a console URL. For+// more information, see Using IAM Roles (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html)+// in the IAM User Guide.+//+// The temporary security credentials created by AssumeRole can be used to make+// API calls to any AWS service with the following exception: you cannot call+// the STS service's GetFederationToken or GetSessionToken APIs.+//+// Optionally, you can pass an IAM access policy to this operation. If you choose+// not to pass a policy, the temporary security credentials that are returned+// by the operation have the permissions that are defined in the access policy+// of the role that is being assumed. If you pass a policy to this operation,+// the temporary security credentials that are returned by the operation have+// the permissions that are allowed by both the access policy of the role that+// is being assumed, and the policy that you pass. This gives you a way to further+// restrict the permissions for the resulting temporary security credentials.+// You cannot use the passed policy to grant permissions that are in excess+// of those allowed by the access policy of the role that is being assumed.+// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,+// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+// in the IAM User Guide.+//+// To assume a role, your AWS account must be trusted by the role. The trust+// relationship is defined in the role's trust policy when the role is created.+// That trust policy states which accounts are allowed to delegate access to+// this account's role.+//+// The user who wants to access the role must also have permissions delegated+// from the role's administrator. If the user is in a different account than+// the role, then the user's administrator must attach a policy that allows+// the user to call AssumeRole on the ARN of the role in the other account.+// If the user is in the same account as the role, then you can either attach+// a policy to the user (identical to the previous different account user),+// or you can add the user as a principal directly in the role's trust policy.+// In this case, the trust policy acts as the only resource-based policy in+// IAM, and users in the same account as the role do not need explicit permission+// to assume the role. For more information about trust policies and resource-based+// policies, see IAM Policies (http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)+// in the IAM User Guide.+//+// Using MFA with AssumeRole+//+// You can optionally include multi-factor authentication (MFA) information+// when you call AssumeRole. This is useful for cross-account scenarios in which+// you want to make sure that the user who is assuming the role has been authenticated+// using an AWS MFA device. In that scenario, the trust policy of the role being+// assumed includes a condition that tests for MFA authentication; if the caller+// does not include valid MFA information, the request to assume the role is+// denied. The condition in a trust policy that tests for MFA authentication+// might look like the following example.+//+// "Condition": {"Bool": {"aws:MultiFactorAuthPresent": true}}+//+// For more information, see Configuring MFA-Protected API Access (http://docs.aws.amazon.com/IAM/latest/UserGuide/MFAProtectedAPI.html)+// in the IAM User Guide guide.+//+// To use MFA with AssumeRole, you pass values for the SerialNumber and TokenCode+// parameters. The SerialNumber value identifies the user's hardware or virtual+// MFA device. The TokenCode is the time-based one-time password (TOTP) that+// the MFA devices produces.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation AssumeRole for usage and error information.+//+// Returned Error Codes:+// * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"+// The request was rejected because the policy document was malformed. The error+// message describes the specific error.+//+// * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"+// The request was rejected because the policy document was too large. The error+// message describes how big the policy document is, in packed form, as a percentage+// of what the API allows.+//+// * ErrCodeRegionDisabledException "RegionDisabledException"+// STS is not activated in the requested region for the account that is being+// asked to generate credentials. The account administrator must use the IAM+// console to activate STS in that region. For more information, see Activating+// and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRole+func (c *STS) AssumeRole(input *AssumeRoleInput) (*AssumeRoleOutput, error) {+ req, out := c.AssumeRoleRequest(input)+ return out, req.Send()+}++// AssumeRoleWithContext is the same as AssumeRole with the addition of+// the ability to pass a context and additional request options.+//+// See AssumeRole for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) AssumeRoleWithContext(ctx aws.Context, input *AssumeRoleInput, opts ...request.Option) (*AssumeRoleOutput, error) {+ req, out := c.AssumeRoleRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opAssumeRoleWithSAML = "AssumeRoleWithSAML"++// AssumeRoleWithSAMLRequest generates a "aws/request.Request" representing the+// client's request for the AssumeRoleWithSAML operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See AssumeRoleWithSAML for more information on using the AssumeRoleWithSAML+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the AssumeRoleWithSAMLRequest method.+// req, resp := client.AssumeRoleWithSAMLRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAML+func (c *STS) AssumeRoleWithSAMLRequest(input *AssumeRoleWithSAMLInput) (req *request.Request, output *AssumeRoleWithSAMLOutput) {+ op := &request.Operation{+ Name: opAssumeRoleWithSAML,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &AssumeRoleWithSAMLInput{}+ }++ output = &AssumeRoleWithSAMLOutput{}+ req = c.newRequest(op, input, output)+ return+}++// AssumeRoleWithSAML API operation for AWS Security Token Service.+//+// Returns a set of temporary security credentials for users who have been authenticated+// via a SAML authentication response. This operation provides a mechanism for+// tying an enterprise identity store or directory to role-based AWS access+// without user-specific credentials or configuration. For a comparison of AssumeRoleWithSAML+// with the other APIs that produce temporary credentials, see Requesting Temporary+// Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)+// in the IAM User Guide.+//+// The temporary security credentials returned by this operation consist of+// an access key ID, a secret access key, and a security token. Applications+// can use these temporary security credentials to sign calls to AWS services.+//+// By default, the temporary security credentials created by AssumeRoleWithSAML+// last for one hour. However, you can use the optional DurationSeconds parameter+// to specify the duration of your session. Your role session lasts for the+// duration that you specify, or until the time specified in the SAML authentication+// response's SessionNotOnOrAfter value, whichever is shorter. You can provide+// a DurationSeconds value from 900 seconds (15 minutes) up to the maximum session+// duration setting for the role. This setting can have a value from 1 hour+// to 12 hours. To learn how to view the maximum value for your role, see View+// the Maximum Session Duration Setting for a Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+// in the IAM User Guide. The maximum session duration limit applies when you+// use the AssumeRole* API operations or the assume-role* CLI operations but+// does not apply when you use those operations to create a console URL. For+// more information, see Using IAM Roles (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html)+// in the IAM User Guide.+//+// The temporary security credentials created by AssumeRoleWithSAML can be used+// to make API calls to any AWS service with the following exception: you cannot+// call the STS service's GetFederationToken or GetSessionToken APIs.+//+// Optionally, you can pass an IAM access policy to this operation. If you choose+// not to pass a policy, the temporary security credentials that are returned+// by the operation have the permissions that are defined in the access policy+// of the role that is being assumed. If you pass a policy to this operation,+// the temporary security credentials that are returned by the operation have+// the permissions that are allowed by the intersection of both the access policy+// of the role that is being assumed, and the policy that you pass. This means+// that both policies must grant the permission for the action to be allowed.+// This gives you a way to further restrict the permissions for the resulting+// temporary security credentials. You cannot use the passed policy to grant+// permissions that are in excess of those allowed by the access policy of the+// role that is being assumed. For more information, see Permissions for AssumeRole,+// AssumeRoleWithSAML, and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+// in the IAM User Guide.+//+// Before your application can call AssumeRoleWithSAML, you must configure your+// SAML identity provider (IdP) to issue the claims required by AWS. Additionally,+// you must use AWS Identity and Access Management (IAM) to create a SAML provider+// entity in your AWS account that represents your identity provider, and create+// an IAM role that specifies this SAML provider in its trust policy.+//+// Calling AssumeRoleWithSAML does not require the use of AWS security credentials.+// The identity of the caller is validated by using keys in the metadata document+// that is uploaded for the SAML provider entity for your identity provider.+//+// Calling AssumeRoleWithSAML can result in an entry in your AWS CloudTrail+// logs. The entry includes the value in the NameID element of the SAML assertion.+// We recommend that you use a NameIDType that is not associated with any personally+// identifiable information (PII). For example, you could instead use the Persistent+// Identifier (urn:oasis:names:tc:SAML:2.0:nameid-format:persistent).+//+// For more information, see the following resources:+//+// * About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)+// in the IAM User Guide.+//+// * Creating SAML Identity Providers (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html)+// in the IAM User Guide.+//+// * Configuring a Relying Party and Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html)+// in the IAM User Guide.+//+// * Creating a Role for SAML 2.0 Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)+// in the IAM User Guide.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation AssumeRoleWithSAML for usage and error information.+//+// Returned Error Codes:+// * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"+// The request was rejected because the policy document was malformed. The error+// message describes the specific error.+//+// * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"+// The request was rejected because the policy document was too large. The error+// message describes how big the policy document is, in packed form, as a percentage+// of what the API allows.+//+// * ErrCodeIDPRejectedClaimException "IDPRejectedClaim"+// The identity provider (IdP) reported that authentication failed. This might+// be because the claim is invalid.+//+// If this error is returned for the AssumeRoleWithWebIdentity operation, it+// can also mean that the claim has expired or has been explicitly revoked.+//+// * ErrCodeInvalidIdentityTokenException "InvalidIdentityToken"+// The web identity token that was passed could not be validated by AWS. Get+// a new identity token from the identity provider and then retry the request.+//+// * ErrCodeExpiredTokenException "ExpiredTokenException"+// The web identity token that was passed is expired or is not valid. Get a+// new identity token from the identity provider and then retry the request.+//+// * ErrCodeRegionDisabledException "RegionDisabledException"+// STS is not activated in the requested region for the account that is being+// asked to generate credentials. The account administrator must use the IAM+// console to activate STS in that region. For more information, see Activating+// and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAML+func (c *STS) AssumeRoleWithSAML(input *AssumeRoleWithSAMLInput) (*AssumeRoleWithSAMLOutput, error) {+ req, out := c.AssumeRoleWithSAMLRequest(input)+ return out, req.Send()+}++// AssumeRoleWithSAMLWithContext is the same as AssumeRoleWithSAML with the addition of+// the ability to pass a context and additional request options.+//+// See AssumeRoleWithSAML for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) AssumeRoleWithSAMLWithContext(ctx aws.Context, input *AssumeRoleWithSAMLInput, opts ...request.Option) (*AssumeRoleWithSAMLOutput, error) {+ req, out := c.AssumeRoleWithSAMLRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opAssumeRoleWithWebIdentity = "AssumeRoleWithWebIdentity"++// AssumeRoleWithWebIdentityRequest generates a "aws/request.Request" representing the+// client's request for the AssumeRoleWithWebIdentity operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See AssumeRoleWithWebIdentity for more information on using the AssumeRoleWithWebIdentity+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the AssumeRoleWithWebIdentityRequest method.+// req, resp := client.AssumeRoleWithWebIdentityRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentity+func (c *STS) AssumeRoleWithWebIdentityRequest(input *AssumeRoleWithWebIdentityInput) (req *request.Request, output *AssumeRoleWithWebIdentityOutput) {+ op := &request.Operation{+ Name: opAssumeRoleWithWebIdentity,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &AssumeRoleWithWebIdentityInput{}+ }++ output = &AssumeRoleWithWebIdentityOutput{}+ req = c.newRequest(op, input, output)+ return+}++// AssumeRoleWithWebIdentity API operation for AWS Security Token Service.+//+// Returns a set of temporary security credentials for users who have been authenticated+// in a mobile or web application with a web identity provider, such as Amazon+// Cognito, Login with Amazon, Facebook, Google, or any OpenID Connect-compatible+// identity provider.+//+// For mobile applications, we recommend that you use Amazon Cognito. You can+// use Amazon Cognito with the AWS SDK for iOS (http://aws.amazon.com/sdkforios/)+// and the AWS SDK for Android (http://aws.amazon.com/sdkforandroid/) to uniquely+// identify a user and supply the user with a consistent identity throughout+// the lifetime of an application.+//+// To learn more about Amazon Cognito, see Amazon Cognito Overview (http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#d0e840)+// in the AWS SDK for Android Developer Guide guide and Amazon Cognito Overview+// (http://docs.aws.amazon.com/mobile/sdkforios/developerguide/cognito-auth.html#d0e664)+// in the AWS SDK for iOS Developer Guide.+//+// Calling AssumeRoleWithWebIdentity does not require the use of AWS security+// credentials. Therefore, you can distribute an application (for example, on+// mobile devices) that requests temporary security credentials without including+// long-term AWS credentials in the application, and without deploying server-based+// proxy services that use long-term AWS credentials. Instead, the identity+// of the caller is validated by using a token from the web identity provider.+// For a comparison of AssumeRoleWithWebIdentity with the other APIs that produce+// temporary credentials, see Requesting Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)+// in the IAM User Guide.+//+// The temporary security credentials returned by this API consist of an access+// key ID, a secret access key, and a security token. Applications can use these+// temporary security credentials to sign calls to AWS service APIs.+//+// By default, the temporary security credentials created by AssumeRoleWithWebIdentity+// last for one hour. However, you can use the optional DurationSeconds parameter+// to specify the duration of your session. You can provide a value from 900+// seconds (15 minutes) up to the maximum session duration setting for the role.+// This setting can have a value from 1 hour to 12 hours. To learn how to view+// the maximum value for your role, see View the Maximum Session Duration Setting+// for a Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+// in the IAM User Guide. The maximum session duration limit applies when you+// use the AssumeRole* API operations or the assume-role* CLI operations but+// does not apply when you use those operations to create a console URL. For+// more information, see Using IAM Roles (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html)+// in the IAM User Guide.+//+// The temporary security credentials created by AssumeRoleWithWebIdentity can+// be used to make API calls to any AWS service with the following exception:+// you cannot call the STS service's GetFederationToken or GetSessionToken APIs.+//+// Optionally, you can pass an IAM access policy to this operation. If you choose+// not to pass a policy, the temporary security credentials that are returned+// by the operation have the permissions that are defined in the access policy+// of the role that is being assumed. If you pass a policy to this operation,+// the temporary security credentials that are returned by the operation have+// the permissions that are allowed by both the access policy of the role that+// is being assumed, and the policy that you pass. This gives you a way to further+// restrict the permissions for the resulting temporary security credentials.+// You cannot use the passed policy to grant permissions that are in excess+// of those allowed by the access policy of the role that is being assumed.+// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,+// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+// in the IAM User Guide.+//+// Before your application can call AssumeRoleWithWebIdentity, you must have+// an identity token from a supported identity provider and create a role that+// the application can assume. The role that your application assumes must trust+// the identity provider that is associated with the identity token. In other+// words, the identity provider must be specified in the role's trust policy.+//+// Calling AssumeRoleWithWebIdentity can result in an entry in your AWS CloudTrail+// logs. The entry includes the Subject (http://openid.net/specs/openid-connect-core-1_0.html#Claims)+// of the provided Web Identity Token. We recommend that you avoid using any+// personally identifiable information (PII) in this field. For example, you+// could instead use a GUID or a pairwise identifier, as suggested in the OIDC+// specification (http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes).+//+// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity+// API, see the following resources:+//+// * Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual.html)+// and Federation Through a Web-based Identity Provider (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).+//+//+// * Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html).+// This interactive website lets you walk through the process of authenticating+// via Login with Amazon, Facebook, or Google, getting temporary security+// credentials, and then using those credentials to make a request to AWS.+//+//+// * AWS SDK for iOS (http://aws.amazon.com/sdkforios/) and AWS SDK for Android+// (http://aws.amazon.com/sdkforandroid/). These toolkits contain sample+// apps that show how to invoke the identity providers, and then how to use+// the information from these providers to get and use temporary security+// credentials.+//+// * Web Identity Federation with Mobile Applications (http://aws.amazon.com/articles/web-identity-federation-with-mobile-applications).+// This article discusses web identity federation and shows an example of+// how to use web identity federation to get access to content in Amazon+// S3.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation AssumeRoleWithWebIdentity for usage and error information.+//+// Returned Error Codes:+// * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"+// The request was rejected because the policy document was malformed. The error+// message describes the specific error.+//+// * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"+// The request was rejected because the policy document was too large. The error+// message describes how big the policy document is, in packed form, as a percentage+// of what the API allows.+//+// * ErrCodeIDPRejectedClaimException "IDPRejectedClaim"+// The identity provider (IdP) reported that authentication failed. This might+// be because the claim is invalid.+//+// If this error is returned for the AssumeRoleWithWebIdentity operation, it+// can also mean that the claim has expired or has been explicitly revoked.+//+// * ErrCodeIDPCommunicationErrorException "IDPCommunicationError"+// The request could not be fulfilled because the non-AWS identity provider+// (IDP) that was asked to verify the incoming identity token could not be reached.+// This is often a transient error caused by network conditions. Retry the request+// a limited number of times so that you don't exceed the request rate. If the+// error persists, the non-AWS identity provider might be down or not responding.+//+// * ErrCodeInvalidIdentityTokenException "InvalidIdentityToken"+// The web identity token that was passed could not be validated by AWS. Get+// a new identity token from the identity provider and then retry the request.+//+// * ErrCodeExpiredTokenException "ExpiredTokenException"+// The web identity token that was passed is expired or is not valid. Get a+// new identity token from the identity provider and then retry the request.+//+// * ErrCodeRegionDisabledException "RegionDisabledException"+// STS is not activated in the requested region for the account that is being+// asked to generate credentials. The account administrator must use the IAM+// console to activate STS in that region. For more information, see Activating+// and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentity+func (c *STS) AssumeRoleWithWebIdentity(input *AssumeRoleWithWebIdentityInput) (*AssumeRoleWithWebIdentityOutput, error) {+ req, out := c.AssumeRoleWithWebIdentityRequest(input)+ return out, req.Send()+}++// AssumeRoleWithWebIdentityWithContext is the same as AssumeRoleWithWebIdentity with the addition of+// the ability to pass a context and additional request options.+//+// See AssumeRoleWithWebIdentity for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) AssumeRoleWithWebIdentityWithContext(ctx aws.Context, input *AssumeRoleWithWebIdentityInput, opts ...request.Option) (*AssumeRoleWithWebIdentityOutput, error) {+ req, out := c.AssumeRoleWithWebIdentityRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opDecodeAuthorizationMessage = "DecodeAuthorizationMessage"++// DecodeAuthorizationMessageRequest generates a "aws/request.Request" representing the+// client's request for the DecodeAuthorizationMessage operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See DecodeAuthorizationMessage for more information on using the DecodeAuthorizationMessage+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the DecodeAuthorizationMessageRequest method.+// req, resp := client.DecodeAuthorizationMessageRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessage+func (c *STS) DecodeAuthorizationMessageRequest(input *DecodeAuthorizationMessageInput) (req *request.Request, output *DecodeAuthorizationMessageOutput) {+ op := &request.Operation{+ Name: opDecodeAuthorizationMessage,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &DecodeAuthorizationMessageInput{}+ }++ output = &DecodeAuthorizationMessageOutput{}+ req = c.newRequest(op, input, output)+ return+}++// DecodeAuthorizationMessage API operation for AWS Security Token Service.+//+// Decodes additional information about the authorization status of a request+// from an encoded message returned in response to an AWS request.+//+// For example, if a user is not authorized to perform an action that he or+// she has requested, the request returns a Client.UnauthorizedOperation response+// (an HTTP 403 response). Some AWS actions additionally return an encoded message+// that can provide details about this authorization failure.+//+// Only certain AWS actions return an encoded authorization message. The documentation+// for an individual action indicates whether that action returns an encoded+// message in addition to returning an HTTP code.+//+// The message is encoded because the details of the authorization status can+// constitute privileged information that the user who requested the action+// should not see. To decode an authorization status message, a user must be+// granted permissions via an IAM policy to request the DecodeAuthorizationMessage+// (sts:DecodeAuthorizationMessage) action.+//+// The decoded message includes the following type of information:+//+// * Whether the request was denied due to an explicit deny or due to the+// absence of an explicit allow. For more information, see Determining Whether+// a Request is Allowed or Denied (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-denyallow)+// in the IAM User Guide.+//+// * The principal who made the request.+//+// * The requested action.+//+// * The requested resource.+//+// * The values of condition keys in the context of the user's request.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation DecodeAuthorizationMessage for usage and error information.+//+// Returned Error Codes:+// * ErrCodeInvalidAuthorizationMessageException "InvalidAuthorizationMessageException"+// The error returned if the message passed to DecodeAuthorizationMessage was+// invalid. This can happen if the token contains invalid characters, such as+// linebreaks.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessage+func (c *STS) DecodeAuthorizationMessage(input *DecodeAuthorizationMessageInput) (*DecodeAuthorizationMessageOutput, error) {+ req, out := c.DecodeAuthorizationMessageRequest(input)+ return out, req.Send()+}++// DecodeAuthorizationMessageWithContext is the same as DecodeAuthorizationMessage with the addition of+// the ability to pass a context and additional request options.+//+// See DecodeAuthorizationMessage for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) DecodeAuthorizationMessageWithContext(ctx aws.Context, input *DecodeAuthorizationMessageInput, opts ...request.Option) (*DecodeAuthorizationMessageOutput, error) {+ req, out := c.DecodeAuthorizationMessageRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetCallerIdentity = "GetCallerIdentity"++// GetCallerIdentityRequest generates a "aws/request.Request" representing the+// client's request for the GetCallerIdentity operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetCallerIdentity for more information on using the GetCallerIdentity+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetCallerIdentityRequest method.+// req, resp := client.GetCallerIdentityRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity+func (c *STS) GetCallerIdentityRequest(input *GetCallerIdentityInput) (req *request.Request, output *GetCallerIdentityOutput) {+ op := &request.Operation{+ Name: opGetCallerIdentity,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &GetCallerIdentityInput{}+ }++ output = &GetCallerIdentityOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetCallerIdentity API operation for AWS Security Token Service.+//+// Returns details about the IAM identity whose credentials are used to call+// the API.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation GetCallerIdentity for usage and error information.+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentity+func (c *STS) GetCallerIdentity(input *GetCallerIdentityInput) (*GetCallerIdentityOutput, error) {+ req, out := c.GetCallerIdentityRequest(input)+ return out, req.Send()+}++// GetCallerIdentityWithContext is the same as GetCallerIdentity with the addition of+// the ability to pass a context and additional request options.+//+// See GetCallerIdentity for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) GetCallerIdentityWithContext(ctx aws.Context, input *GetCallerIdentityInput, opts ...request.Option) (*GetCallerIdentityOutput, error) {+ req, out := c.GetCallerIdentityRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetFederationToken = "GetFederationToken"++// GetFederationTokenRequest generates a "aws/request.Request" representing the+// client's request for the GetFederationToken operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetFederationToken for more information on using the GetFederationToken+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetFederationTokenRequest method.+// req, resp := client.GetFederationTokenRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationToken+func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *request.Request, output *GetFederationTokenOutput) {+ op := &request.Operation{+ Name: opGetFederationToken,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &GetFederationTokenInput{}+ }++ output = &GetFederationTokenOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetFederationToken API operation for AWS Security Token Service.+//+// Returns a set of temporary security credentials (consisting of an access+// key ID, a secret access key, and a security token) for a federated user.+// A typical use is in a proxy application that gets temporary security credentials+// on behalf of distributed applications inside a corporate network. Because+// you must call the GetFederationToken action using the long-term security+// credentials of an IAM user, this call is appropriate in contexts where those+// credentials can be safely stored, usually in a server-based application.+// For a comparison of GetFederationToken with the other APIs that produce temporary+// credentials, see Requesting Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)+// in the IAM User Guide.+//+// If you are creating a mobile-based or browser-based app that can authenticate+// users using a web identity provider like Login with Amazon, Facebook, Google,+// or an OpenID Connect-compatible identity provider, we recommend that you+// use Amazon Cognito (http://aws.amazon.com/cognito/) or AssumeRoleWithWebIdentity.+// For more information, see Federation Through a Web-based Identity Provider+// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).+//+// The GetFederationToken action must be called by using the long-term AWS security+// credentials of an IAM user. You can also call GetFederationToken using the+// security credentials of an AWS root account, but we do not recommended it.+// Instead, we recommend that you create an IAM user for the purpose of the+// proxy application and then attach a policy to the IAM user that limits federated+// users to only the actions and resources that they need access to. For more+// information, see IAM Best Practices (http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)+// in the IAM User Guide.+//+// The temporary security credentials that are obtained by using the long-term+// credentials of an IAM user are valid for the specified duration, from 900+// seconds (15 minutes) up to a maximium of 129600 seconds (36 hours). The default+// is 43200 seconds (12 hours). Temporary credentials that are obtained by using+// AWS root account credentials have a maximum duration of 3600 seconds (1 hour).+//+// The temporary security credentials created by GetFederationToken can be used+// to make API calls to any AWS service with the following exceptions:+//+// * You cannot use these credentials to call any IAM APIs.+//+// * You cannot call any STS APIs except GetCallerIdentity.+//+// Permissions+//+// The permissions for the temporary security credentials returned by GetFederationToken+// are determined by a combination of the following:+//+// * The policy or policies that are attached to the IAM user whose credentials+// are used to call GetFederationToken.+//+// * The policy that is passed as a parameter in the call.+//+// The passed policy is attached to the temporary security credentials that+// result from the GetFederationToken API call--that is, to the federated user.+// When the federated user makes an AWS request, AWS evaluates the policy attached+// to the federated user in combination with the policy or policies attached+// to the IAM user whose credentials were used to call GetFederationToken. AWS+// allows the federated user's request only when both the federated user and+// the IAM user are explicitly allowed to perform the requested action. The+// passed policy cannot grant more permissions than those that are defined in+// the IAM user policy.+//+// A typical use case is that the permissions of the IAM user whose credentials+// are used to call GetFederationToken are designed to allow access to all the+// actions and resources that any federated user will need. Then, for individual+// users, you pass a policy to the operation that scopes down the permissions+// to a level that's appropriate to that individual user, using a policy that+// allows only a subset of permissions that are granted to the IAM user.+//+// If you do not pass a policy, the resulting temporary security credentials+// have no effective permissions. The only exception is when the temporary security+// credentials are used to access a resource that has a resource-based policy+// that specifically allows the federated user to access the resource.+//+// For more information about how permissions work, see Permissions for GetFederationToken+// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html).+// For information about using GetFederationToken to create temporary security+// credentials, see GetFederationToken—Federation Through a Custom Identity+// Broker (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getfederationtoken).+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation GetFederationToken for usage and error information.+//+// Returned Error Codes:+// * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"+// The request was rejected because the policy document was malformed. The error+// message describes the specific error.+//+// * ErrCodePackedPolicyTooLargeException "PackedPolicyTooLarge"+// The request was rejected because the policy document was too large. The error+// message describes how big the policy document is, in packed form, as a percentage+// of what the API allows.+//+// * ErrCodeRegionDisabledException "RegionDisabledException"+// STS is not activated in the requested region for the account that is being+// asked to generate credentials. The account administrator must use the IAM+// console to activate STS in that region. For more information, see Activating+// and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationToken+func (c *STS) GetFederationToken(input *GetFederationTokenInput) (*GetFederationTokenOutput, error) {+ req, out := c.GetFederationTokenRequest(input)+ return out, req.Send()+}++// GetFederationTokenWithContext is the same as GetFederationToken with the addition of+// the ability to pass a context and additional request options.+//+// See GetFederationToken for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) GetFederationTokenWithContext(ctx aws.Context, input *GetFederationTokenInput, opts ...request.Option) (*GetFederationTokenOutput, error) {+ req, out := c.GetFederationTokenRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++const opGetSessionToken = "GetSessionToken"++// GetSessionTokenRequest generates a "aws/request.Request" representing the+// client's request for the GetSessionToken operation. The "output" return+// value will be populated with the request's response once the request completes+// successfully.+//+// Use "Send" method on the returned Request to send the API call to the service.+// the "output" return value is not valid until after Send returns without error.+//+// See GetSessionToken for more information on using the GetSessionToken+// API call, and error handling.+//+// This method is useful when you want to inject custom logic or configuration+// into the SDK's request lifecycle. Such as custom headers, or retry logic.+//+//+// // Example sending a request using the GetSessionTokenRequest method.+// req, resp := client.GetSessionTokenRequest(params)+//+// err := req.Send()+// if err == nil { // resp is now filled+// fmt.Println(resp)+// }+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionToken+func (c *STS) GetSessionTokenRequest(input *GetSessionTokenInput) (req *request.Request, output *GetSessionTokenOutput) {+ op := &request.Operation{+ Name: opGetSessionToken,+ HTTPMethod: "POST",+ HTTPPath: "/",+ }++ if input == nil {+ input = &GetSessionTokenInput{}+ }++ output = &GetSessionTokenOutput{}+ req = c.newRequest(op, input, output)+ return+}++// GetSessionToken API operation for AWS Security Token Service.+//+// Returns a set of temporary credentials for an AWS account or IAM user. The+// credentials consist of an access key ID, a secret access key, and a security+// token. Typically, you use GetSessionToken if you want to use MFA to protect+// programmatic calls to specific AWS APIs like Amazon EC2 StopInstances. MFA-enabled+// IAM users would need to call GetSessionToken and submit an MFA code that+// is associated with their MFA device. Using the temporary security credentials+// that are returned from the call, IAM users can then make programmatic calls+// to APIs that require MFA authentication. If you do not supply a correct MFA+// code, then the API returns an access denied error. For a comparison of GetSessionToken+// with the other APIs that produce temporary credentials, see Requesting Temporary+// Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)+// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)+// in the IAM User Guide.+//+// The GetSessionToken action must be called by using the long-term AWS security+// credentials of the AWS account or an IAM user. Credentials that are created+// by IAM users are valid for the duration that you specify, from 900 seconds+// (15 minutes) up to a maximum of 129600 seconds (36 hours), with a default+// of 43200 seconds (12 hours); credentials that are created by using account+// credentials can range from 900 seconds (15 minutes) up to a maximum of 3600+// seconds (1 hour), with a default of 1 hour.+//+// The temporary security credentials created by GetSessionToken can be used+// to make API calls to any AWS service with the following exceptions:+//+// * You cannot call any IAM APIs unless MFA authentication information is+// included in the request.+//+// * You cannot call any STS API exceptAssumeRole or GetCallerIdentity.+//+// We recommend that you do not call GetSessionToken with root account credentials.+// Instead, follow our best practices (http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users)+// by creating one or more IAM users, giving them the necessary permissions,+// and using IAM users for everyday interaction with AWS.+//+// The permissions associated with the temporary security credentials returned+// by GetSessionToken are based on the permissions associated with account or+// IAM user whose credentials are used to call the action. If GetSessionToken+// is called using root account credentials, the temporary credentials have+// root account permissions. Similarly, if GetSessionToken is called using the+// credentials of an IAM user, the temporary credentials have the same permissions+// as the IAM user.+//+// For more information about using GetSessionToken to create temporary credentials,+// go to Temporary Credentials for Users in Untrusted Environments (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken)+// in the IAM User Guide.+//+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions+// with awserr.Error's Code and Message methods to get detailed information about+// the error.+//+// See the AWS API reference guide for AWS Security Token Service's+// API operation GetSessionToken for usage and error information.+//+// Returned Error Codes:+// * ErrCodeRegionDisabledException "RegionDisabledException"+// STS is not activated in the requested region for the account that is being+// asked to generate credentials. The account administrator must use the IAM+// console to activate STS in that region. For more information, see Activating+// and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// See also, https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionToken+func (c *STS) GetSessionToken(input *GetSessionTokenInput) (*GetSessionTokenOutput, error) {+ req, out := c.GetSessionTokenRequest(input)+ return out, req.Send()+}++// GetSessionTokenWithContext is the same as GetSessionToken with the addition of+// the ability to pass a context and additional request options.+//+// See GetSessionToken for details on how to use this API operation.+//+// The context must be non-nil and will be used for request cancellation. If+// the context is nil a panic will occur. In the future the SDK may create+// sub-contexts for http.Requests. See https://golang.org/pkg/context/+// for more information on using Contexts.+func (c *STS) GetSessionTokenWithContext(ctx aws.Context, input *GetSessionTokenInput, opts ...request.Option) (*GetSessionTokenOutput, error) {+ req, out := c.GetSessionTokenRequest(input)+ req.SetContext(ctx)+ req.ApplyOptions(opts...)+ return out, req.Send()+}++type AssumeRoleInput struct {+ _ struct{} `type:"structure"`++ // The duration, in seconds, of the role session. The value can range from 900+ // seconds (15 minutes) up to the maximum session duration setting for the role.+ // This setting can have a value from 1 hour to 12 hours. If you specify a value+ // higher than this setting, the operation fails. For example, if you specify+ // a session duration of 12 hours, but your administrator set the maximum session+ // duration to 6 hours, your operation fails. To learn how to view the maximum+ // value for your role, see View the Maximum Session Duration Setting for a+ // Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+ // in the IAM User Guide.+ //+ // By default, the value is set to 3600 seconds.+ //+ // The DurationSeconds parameter is separate from the duration of a console+ // session that you might request using the returned credentials. The request+ // to the federation endpoint for a console sign-in token takes a SessionDuration+ // parameter that specifies the maximum length of the console session. For more+ // information, see Creating a URL that Enables Federated Users to Access the+ // AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)+ // in the IAM User Guide.+ DurationSeconds *int64 `min:"900" type:"integer"`++ // A unique identifier that is used by third parties when assuming roles in+ // their customers' accounts. For each role that the third party can assume,+ // they should instruct their customers to ensure the role's trust policy checks+ // for the external ID that the third party generated. Each time the third party+ // assumes the role, they should pass the customer's external ID. The external+ // ID is useful in order to help third parties bind a role to the customer who+ // created it. For more information about the external ID, see How to Use an+ // External ID When Granting Access to Your AWS Resources to a Third Party (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html)+ // in the IAM User Guide.+ //+ // The regex used to validated this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@:/-+ ExternalId *string `min:"2" type:"string"`++ // An IAM policy in JSON format.+ //+ // This parameter is optional. If you pass a policy, the temporary security+ // credentials that are returned by the operation have the permissions that+ // are allowed by both (the intersection of) the access policy of the role that+ // is being assumed, and the policy that you pass. This gives you a way to further+ // restrict the permissions for the resulting temporary security credentials.+ // You cannot use the passed policy to grant permissions that are in excess+ // of those allowed by the access policy of the role that is being assumed.+ // For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,+ // and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+ // in the IAM User Guide.+ //+ // The format for this parameter, as described by its regex pattern, is a string+ // of characters up to 2048 characters in length. The characters can be any+ // ASCII character from the space character to the end of the valid character+ // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),+ // and carriage return (\u000D) characters.+ //+ // The policy plain text must be 2048 bytes or shorter. However, an internal+ // conversion compresses it into a packed binary format with a separate limit.+ // The PackedPolicySize response element indicates by percentage how close to+ // the upper size limit the policy is, with 100% equaling the maximum allowed+ // size.+ Policy *string `min:"1" type:"string"`++ // The Amazon Resource Name (ARN) of the role to assume.+ //+ // RoleArn is a required field+ RoleArn *string `min:"20" type:"string" required:"true"`++ // An identifier for the assumed role session.+ //+ // Use the role session name to uniquely identify a session when the same role+ // is assumed by different principals or for different reasons. In cross-account+ // scenarios, the role session name is visible to, and can be logged by the+ // account that owns the role. The role session name is also used in the ARN+ // of the assumed role principal. This means that subsequent cross-account API+ // requests using the temporary security credentials will expose the role session+ // name to the external account in their CloudTrail logs.+ //+ // The regex used to validate this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@-+ //+ // RoleSessionName is a required field+ RoleSessionName *string `min:"2" type:"string" required:"true"`++ // The identification number of the MFA device that is associated with the user+ // who is making the AssumeRole call. Specify this value if the trust policy+ // of the role being assumed includes a condition that requires MFA authentication.+ // The value is either the serial number for a hardware device (such as GAHT12345678)+ // or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).+ //+ // The regex used to validate this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@-+ SerialNumber *string `min:"9" type:"string"`++ // The value provided by the MFA device, if the trust policy of the role being+ // assumed requires MFA (that is, if the policy includes a condition that tests+ // for MFA). If the role being assumed requires MFA and if the TokenCode value+ // is missing or expired, the AssumeRole call returns an "access denied" error.+ //+ // The format for this parameter, as described by its regex pattern, is a sequence+ // of six numeric digits.+ TokenCode *string `min:"6" type:"string"`+}++// String returns the string representation+func (s AssumeRoleInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AssumeRoleInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AssumeRoleInput"}+ if s.DurationSeconds != nil && *s.DurationSeconds < 900 {+ invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))+ }+ if s.ExternalId != nil && len(*s.ExternalId) < 2 {+ invalidParams.Add(request.NewErrParamMinLen("ExternalId", 2))+ }+ if s.Policy != nil && len(*s.Policy) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Policy", 1))+ }+ if s.RoleArn == nil {+ invalidParams.Add(request.NewErrParamRequired("RoleArn"))+ }+ if s.RoleArn != nil && len(*s.RoleArn) < 20 {+ invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))+ }+ if s.RoleSessionName == nil {+ invalidParams.Add(request.NewErrParamRequired("RoleSessionName"))+ }+ if s.RoleSessionName != nil && len(*s.RoleSessionName) < 2 {+ invalidParams.Add(request.NewErrParamMinLen("RoleSessionName", 2))+ }+ if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {+ invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))+ }+ if s.TokenCode != nil && len(*s.TokenCode) < 6 {+ invalidParams.Add(request.NewErrParamMinLen("TokenCode", 6))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDurationSeconds sets the DurationSeconds field's value.+func (s *AssumeRoleInput) SetDurationSeconds(v int64) *AssumeRoleInput {+ s.DurationSeconds = &v+ return s+}++// SetExternalId sets the ExternalId field's value.+func (s *AssumeRoleInput) SetExternalId(v string) *AssumeRoleInput {+ s.ExternalId = &v+ return s+}++// SetPolicy sets the Policy field's value.+func (s *AssumeRoleInput) SetPolicy(v string) *AssumeRoleInput {+ s.Policy = &v+ return s+}++// SetRoleArn sets the RoleArn field's value.+func (s *AssumeRoleInput) SetRoleArn(v string) *AssumeRoleInput {+ s.RoleArn = &v+ return s+}++// SetRoleSessionName sets the RoleSessionName field's value.+func (s *AssumeRoleInput) SetRoleSessionName(v string) *AssumeRoleInput {+ s.RoleSessionName = &v+ return s+}++// SetSerialNumber sets the SerialNumber field's value.+func (s *AssumeRoleInput) SetSerialNumber(v string) *AssumeRoleInput {+ s.SerialNumber = &v+ return s+}++// SetTokenCode sets the TokenCode field's value.+func (s *AssumeRoleInput) SetTokenCode(v string) *AssumeRoleInput {+ s.TokenCode = &v+ return s+}++// Contains the response to a successful AssumeRole request, including temporary+// AWS credentials that can be used to make AWS requests.+type AssumeRoleOutput struct {+ _ struct{} `type:"structure"`++ // The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers+ // that you can use to refer to the resulting temporary security credentials.+ // For example, you can reference these credentials as a principal in a resource-based+ // policy by using the ARN or assumed role ID. The ARN and ID include the RoleSessionName+ // that you specified when you called AssumeRole.+ AssumedRoleUser *AssumedRoleUser `type:"structure"`++ // The temporary security credentials, which include an access key ID, a secret+ // access key, and a security (or session) token.+ //+ // Note: The size of the security token that STS APIs return is not fixed. We+ // strongly recommend that you make no assumptions about the maximum size. As+ // of this writing, the typical size is less than 4096 bytes, but that can vary.+ // Also, future updates to AWS might require larger sizes.+ Credentials *Credentials `type:"structure"`++ // A percentage value that indicates the size of the policy in packed form.+ // The service rejects any policy with a packed size greater than 100 percent,+ // which means the policy exceeded the allowed space.+ PackedPolicySize *int64 `type:"integer"`+}++// String returns the string representation+func (s AssumeRoleOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleOutput) GoString() string {+ return s.String()+}++// SetAssumedRoleUser sets the AssumedRoleUser field's value.+func (s *AssumeRoleOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleOutput {+ s.AssumedRoleUser = v+ return s+}++// SetCredentials sets the Credentials field's value.+func (s *AssumeRoleOutput) SetCredentials(v *Credentials) *AssumeRoleOutput {+ s.Credentials = v+ return s+}++// SetPackedPolicySize sets the PackedPolicySize field's value.+func (s *AssumeRoleOutput) SetPackedPolicySize(v int64) *AssumeRoleOutput {+ s.PackedPolicySize = &v+ return s+}++type AssumeRoleWithSAMLInput struct {+ _ struct{} `type:"structure"`++ // The duration, in seconds, of the role session. Your role session lasts for+ // the duration that you specify for the DurationSeconds parameter, or until+ // the time specified in the SAML authentication response's SessionNotOnOrAfter+ // value, whichever is shorter. You can provide a DurationSeconds value from+ // 900 seconds (15 minutes) up to the maximum session duration setting for the+ // role. This setting can have a value from 1 hour to 12 hours. If you specify+ // a value higher than this setting, the operation fails. For example, if you+ // specify a session duration of 12 hours, but your administrator set the maximum+ // session duration to 6 hours, your operation fails. To learn how to view the+ // maximum value for your role, see View the Maximum Session Duration Setting+ // for a Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+ // in the IAM User Guide.+ //+ // By default, the value is set to 3600 seconds.+ //+ // The DurationSeconds parameter is separate from the duration of a console+ // session that you might request using the returned credentials. The request+ // to the federation endpoint for a console sign-in token takes a SessionDuration+ // parameter that specifies the maximum length of the console session. For more+ // information, see Creating a URL that Enables Federated Users to Access the+ // AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)+ // in the IAM User Guide.+ DurationSeconds *int64 `min:"900" type:"integer"`++ // An IAM policy in JSON format.+ //+ // The policy parameter is optional. If you pass a policy, the temporary security+ // credentials that are returned by the operation have the permissions that+ // are allowed by both the access policy of the role that is being assumed,+ // and the policy that you pass. This gives you a way to further restrict the+ // permissions for the resulting temporary security credentials. You cannot+ // use the passed policy to grant permissions that are in excess of those allowed+ // by the access policy of the role that is being assumed. For more information,+ // Permissions for AssumeRole, AssumeRoleWithSAML, and AssumeRoleWithWebIdentity+ // (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+ // in the IAM User Guide.+ //+ // The format for this parameter, as described by its regex pattern, is a string+ // of characters up to 2048 characters in length. The characters can be any+ // ASCII character from the space character to the end of the valid character+ // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),+ // and carriage return (\u000D) characters.+ //+ // The policy plain text must be 2048 bytes or shorter. However, an internal+ // conversion compresses it into a packed binary format with a separate limit.+ // The PackedPolicySize response element indicates by percentage how close to+ // the upper size limit the policy is, with 100% equaling the maximum allowed+ // size.+ Policy *string `min:"1" type:"string"`++ // The Amazon Resource Name (ARN) of the SAML provider in IAM that describes+ // the IdP.+ //+ // PrincipalArn is a required field+ PrincipalArn *string `min:"20" type:"string" required:"true"`++ // The Amazon Resource Name (ARN) of the role that the caller is assuming.+ //+ // RoleArn is a required field+ RoleArn *string `min:"20" type:"string" required:"true"`++ // The base-64 encoded SAML authentication response provided by the IdP.+ //+ // For more information, see Configuring a Relying Party and Adding Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/create-role-saml-IdP-tasks.html)+ // in the Using IAM guide.+ //+ // SAMLAssertion is a required field+ SAMLAssertion *string `min:"4" type:"string" required:"true"`+}++// String returns the string representation+func (s AssumeRoleWithSAMLInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleWithSAMLInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AssumeRoleWithSAMLInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AssumeRoleWithSAMLInput"}+ if s.DurationSeconds != nil && *s.DurationSeconds < 900 {+ invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))+ }+ if s.Policy != nil && len(*s.Policy) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Policy", 1))+ }+ if s.PrincipalArn == nil {+ invalidParams.Add(request.NewErrParamRequired("PrincipalArn"))+ }+ if s.PrincipalArn != nil && len(*s.PrincipalArn) < 20 {+ invalidParams.Add(request.NewErrParamMinLen("PrincipalArn", 20))+ }+ if s.RoleArn == nil {+ invalidParams.Add(request.NewErrParamRequired("RoleArn"))+ }+ if s.RoleArn != nil && len(*s.RoleArn) < 20 {+ invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))+ }+ if s.SAMLAssertion == nil {+ invalidParams.Add(request.NewErrParamRequired("SAMLAssertion"))+ }+ if s.SAMLAssertion != nil && len(*s.SAMLAssertion) < 4 {+ invalidParams.Add(request.NewErrParamMinLen("SAMLAssertion", 4))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDurationSeconds sets the DurationSeconds field's value.+func (s *AssumeRoleWithSAMLInput) SetDurationSeconds(v int64) *AssumeRoleWithSAMLInput {+ s.DurationSeconds = &v+ return s+}++// SetPolicy sets the Policy field's value.+func (s *AssumeRoleWithSAMLInput) SetPolicy(v string) *AssumeRoleWithSAMLInput {+ s.Policy = &v+ return s+}++// SetPrincipalArn sets the PrincipalArn field's value.+func (s *AssumeRoleWithSAMLInput) SetPrincipalArn(v string) *AssumeRoleWithSAMLInput {+ s.PrincipalArn = &v+ return s+}++// SetRoleArn sets the RoleArn field's value.+func (s *AssumeRoleWithSAMLInput) SetRoleArn(v string) *AssumeRoleWithSAMLInput {+ s.RoleArn = &v+ return s+}++// SetSAMLAssertion sets the SAMLAssertion field's value.+func (s *AssumeRoleWithSAMLInput) SetSAMLAssertion(v string) *AssumeRoleWithSAMLInput {+ s.SAMLAssertion = &v+ return s+}++// Contains the response to a successful AssumeRoleWithSAML request, including+// temporary AWS credentials that can be used to make AWS requests.+type AssumeRoleWithSAMLOutput struct {+ _ struct{} `type:"structure"`++ // The identifiers for the temporary security credentials that the operation+ // returns.+ AssumedRoleUser *AssumedRoleUser `type:"structure"`++ // The value of the Recipient attribute of the SubjectConfirmationData element+ // of the SAML assertion.+ Audience *string `type:"string"`++ // The temporary security credentials, which include an access key ID, a secret+ // access key, and a security (or session) token.+ //+ // Note: The size of the security token that STS APIs return is not fixed. We+ // strongly recommend that you make no assumptions about the maximum size. As+ // of this writing, the typical size is less than 4096 bytes, but that can vary.+ // Also, future updates to AWS might require larger sizes.+ Credentials *Credentials `type:"structure"`++ // The value of the Issuer element of the SAML assertion.+ Issuer *string `type:"string"`++ // A hash value based on the concatenation of the Issuer response value, the+ // AWS account ID, and the friendly name (the last part of the ARN) of the SAML+ // provider in IAM. The combination of NameQualifier and Subject can be used+ // to uniquely identify a federated user.+ //+ // The following pseudocode shows how the hash value is calculated:+ //+ // BASE64 ( SHA1 ( "https://example.com/saml" + "123456789012" + "/MySAMLIdP"+ // ) )+ NameQualifier *string `type:"string"`++ // A percentage value that indicates the size of the policy in packed form.+ // The service rejects any policy with a packed size greater than 100 percent,+ // which means the policy exceeded the allowed space.+ PackedPolicySize *int64 `type:"integer"`++ // The value of the NameID element in the Subject element of the SAML assertion.+ Subject *string `type:"string"`++ // The format of the name ID, as defined by the Format attribute in the NameID+ // element of the SAML assertion. Typical examples of the format are transient+ // or persistent.+ //+ // If the format includes the prefix urn:oasis:names:tc:SAML:2.0:nameid-format,+ // that prefix is removed. For example, urn:oasis:names:tc:SAML:2.0:nameid-format:transient+ // is returned as transient. If the format includes any other prefix, the format+ // is returned with no modifications.+ SubjectType *string `type:"string"`+}++// String returns the string representation+func (s AssumeRoleWithSAMLOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleWithSAMLOutput) GoString() string {+ return s.String()+}++// SetAssumedRoleUser sets the AssumedRoleUser field's value.+func (s *AssumeRoleWithSAMLOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleWithSAMLOutput {+ s.AssumedRoleUser = v+ return s+}++// SetAudience sets the Audience field's value.+func (s *AssumeRoleWithSAMLOutput) SetAudience(v string) *AssumeRoleWithSAMLOutput {+ s.Audience = &v+ return s+}++// SetCredentials sets the Credentials field's value.+func (s *AssumeRoleWithSAMLOutput) SetCredentials(v *Credentials) *AssumeRoleWithSAMLOutput {+ s.Credentials = v+ return s+}++// SetIssuer sets the Issuer field's value.+func (s *AssumeRoleWithSAMLOutput) SetIssuer(v string) *AssumeRoleWithSAMLOutput {+ s.Issuer = &v+ return s+}++// SetNameQualifier sets the NameQualifier field's value.+func (s *AssumeRoleWithSAMLOutput) SetNameQualifier(v string) *AssumeRoleWithSAMLOutput {+ s.NameQualifier = &v+ return s+}++// SetPackedPolicySize sets the PackedPolicySize field's value.+func (s *AssumeRoleWithSAMLOutput) SetPackedPolicySize(v int64) *AssumeRoleWithSAMLOutput {+ s.PackedPolicySize = &v+ return s+}++// SetSubject sets the Subject field's value.+func (s *AssumeRoleWithSAMLOutput) SetSubject(v string) *AssumeRoleWithSAMLOutput {+ s.Subject = &v+ return s+}++// SetSubjectType sets the SubjectType field's value.+func (s *AssumeRoleWithSAMLOutput) SetSubjectType(v string) *AssumeRoleWithSAMLOutput {+ s.SubjectType = &v+ return s+}++type AssumeRoleWithWebIdentityInput struct {+ _ struct{} `type:"structure"`++ // The duration, in seconds, of the role session. The value can range from 900+ // seconds (15 minutes) up to the maximum session duration setting for the role.+ // This setting can have a value from 1 hour to 12 hours. If you specify a value+ // higher than this setting, the operation fails. For example, if you specify+ // a session duration of 12 hours, but your administrator set the maximum session+ // duration to 6 hours, your operation fails. To learn how to view the maximum+ // value for your role, see View the Maximum Session Duration Setting for a+ // Role (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session)+ // in the IAM User Guide.+ //+ // By default, the value is set to 3600 seconds.+ //+ // The DurationSeconds parameter is separate from the duration of a console+ // session that you might request using the returned credentials. The request+ // to the federation endpoint for a console sign-in token takes a SessionDuration+ // parameter that specifies the maximum length of the console session. For more+ // information, see Creating a URL that Enables Federated Users to Access the+ // AWS Management Console (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)+ // in the IAM User Guide.+ DurationSeconds *int64 `min:"900" type:"integer"`++ // An IAM policy in JSON format.+ //+ // The policy parameter is optional. If you pass a policy, the temporary security+ // credentials that are returned by the operation have the permissions that+ // are allowed by both the access policy of the role that is being assumed,+ // and the policy that you pass. This gives you a way to further restrict the+ // permissions for the resulting temporary security credentials. You cannot+ // use the passed policy to grant permissions that are in excess of those allowed+ // by the access policy of the role that is being assumed. For more information,+ // see Permissions for AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)+ // in the IAM User Guide.+ //+ // The format for this parameter, as described by its regex pattern, is a string+ // of characters up to 2048 characters in length. The characters can be any+ // ASCII character from the space character to the end of the valid character+ // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),+ // and carriage return (\u000D) characters.+ //+ // The policy plain text must be 2048 bytes or shorter. However, an internal+ // conversion compresses it into a packed binary format with a separate limit.+ // The PackedPolicySize response element indicates by percentage how close to+ // the upper size limit the policy is, with 100% equaling the maximum allowed+ // size.+ Policy *string `min:"1" type:"string"`++ // The fully qualified host component of the domain name of the identity provider.+ //+ // Specify this value only for OAuth 2.0 access tokens. Currently www.amazon.com+ // and graph.facebook.com are the only supported identity providers for OAuth+ // 2.0 access tokens. Do not include URL schemes and port numbers.+ //+ // Do not specify this value for OpenID Connect ID tokens.+ ProviderId *string `min:"4" type:"string"`++ // The Amazon Resource Name (ARN) of the role that the caller is assuming.+ //+ // RoleArn is a required field+ RoleArn *string `min:"20" type:"string" required:"true"`++ // An identifier for the assumed role session. Typically, you pass the name+ // or identifier that is associated with the user who is using your application.+ // That way, the temporary security credentials that your application will use+ // are associated with that user. This session name is included as part of the+ // ARN and assumed role ID in the AssumedRoleUser response element.+ //+ // The regex used to validate this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@-+ //+ // RoleSessionName is a required field+ RoleSessionName *string `min:"2" type:"string" required:"true"`++ // The OAuth 2.0 access token or OpenID Connect ID token that is provided by+ // the identity provider. Your application must get this token by authenticating+ // the user who is using your application with a web identity provider before+ // the application makes an AssumeRoleWithWebIdentity call.+ //+ // WebIdentityToken is a required field+ WebIdentityToken *string `min:"4" type:"string" required:"true"`+}++// String returns the string representation+func (s AssumeRoleWithWebIdentityInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleWithWebIdentityInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *AssumeRoleWithWebIdentityInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "AssumeRoleWithWebIdentityInput"}+ if s.DurationSeconds != nil && *s.DurationSeconds < 900 {+ invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))+ }+ if s.Policy != nil && len(*s.Policy) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Policy", 1))+ }+ if s.ProviderId != nil && len(*s.ProviderId) < 4 {+ invalidParams.Add(request.NewErrParamMinLen("ProviderId", 4))+ }+ if s.RoleArn == nil {+ invalidParams.Add(request.NewErrParamRequired("RoleArn"))+ }+ if s.RoleArn != nil && len(*s.RoleArn) < 20 {+ invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))+ }+ if s.RoleSessionName == nil {+ invalidParams.Add(request.NewErrParamRequired("RoleSessionName"))+ }+ if s.RoleSessionName != nil && len(*s.RoleSessionName) < 2 {+ invalidParams.Add(request.NewErrParamMinLen("RoleSessionName", 2))+ }+ if s.WebIdentityToken == nil {+ invalidParams.Add(request.NewErrParamRequired("WebIdentityToken"))+ }+ if s.WebIdentityToken != nil && len(*s.WebIdentityToken) < 4 {+ invalidParams.Add(request.NewErrParamMinLen("WebIdentityToken", 4))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDurationSeconds sets the DurationSeconds field's value.+func (s *AssumeRoleWithWebIdentityInput) SetDurationSeconds(v int64) *AssumeRoleWithWebIdentityInput {+ s.DurationSeconds = &v+ return s+}++// SetPolicy sets the Policy field's value.+func (s *AssumeRoleWithWebIdentityInput) SetPolicy(v string) *AssumeRoleWithWebIdentityInput {+ s.Policy = &v+ return s+}++// SetProviderId sets the ProviderId field's value.+func (s *AssumeRoleWithWebIdentityInput) SetProviderId(v string) *AssumeRoleWithWebIdentityInput {+ s.ProviderId = &v+ return s+}++// SetRoleArn sets the RoleArn field's value.+func (s *AssumeRoleWithWebIdentityInput) SetRoleArn(v string) *AssumeRoleWithWebIdentityInput {+ s.RoleArn = &v+ return s+}++// SetRoleSessionName sets the RoleSessionName field's value.+func (s *AssumeRoleWithWebIdentityInput) SetRoleSessionName(v string) *AssumeRoleWithWebIdentityInput {+ s.RoleSessionName = &v+ return s+}++// SetWebIdentityToken sets the WebIdentityToken field's value.+func (s *AssumeRoleWithWebIdentityInput) SetWebIdentityToken(v string) *AssumeRoleWithWebIdentityInput {+ s.WebIdentityToken = &v+ return s+}++// Contains the response to a successful AssumeRoleWithWebIdentity request,+// including temporary AWS credentials that can be used to make AWS requests.+type AssumeRoleWithWebIdentityOutput struct {+ _ struct{} `type:"structure"`++ // The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers+ // that you can use to refer to the resulting temporary security credentials.+ // For example, you can reference these credentials as a principal in a resource-based+ // policy by using the ARN or assumed role ID. The ARN and ID include the RoleSessionName+ // that you specified when you called AssumeRole.+ AssumedRoleUser *AssumedRoleUser `type:"structure"`++ // The intended audience (also known as client ID) of the web identity token.+ // This is traditionally the client identifier issued to the application that+ // requested the web identity token.+ Audience *string `type:"string"`++ // The temporary security credentials, which include an access key ID, a secret+ // access key, and a security token.+ //+ // Note: The size of the security token that STS APIs return is not fixed. We+ // strongly recommend that you make no assumptions about the maximum size. As+ // of this writing, the typical size is less than 4096 bytes, but that can vary.+ // Also, future updates to AWS might require larger sizes.+ Credentials *Credentials `type:"structure"`++ // A percentage value that indicates the size of the policy in packed form.+ // The service rejects any policy with a packed size greater than 100 percent,+ // which means the policy exceeded the allowed space.+ PackedPolicySize *int64 `type:"integer"`++ // The issuing authority of the web identity token presented. For OpenID Connect+ // ID Tokens this contains the value of the iss field. For OAuth 2.0 access+ // tokens, this contains the value of the ProviderId parameter that was passed+ // in the AssumeRoleWithWebIdentity request.+ Provider *string `type:"string"`++ // The unique user identifier that is returned by the identity provider. This+ // identifier is associated with the WebIdentityToken that was submitted with+ // the AssumeRoleWithWebIdentity call. The identifier is typically unique to+ // the user and the application that acquired the WebIdentityToken (pairwise+ // identifier). For OpenID Connect ID tokens, this field contains the value+ // returned by the identity provider as the token's sub (Subject) claim.+ SubjectFromWebIdentityToken *string `min:"6" type:"string"`+}++// String returns the string representation+func (s AssumeRoleWithWebIdentityOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumeRoleWithWebIdentityOutput) GoString() string {+ return s.String()+}++// SetAssumedRoleUser sets the AssumedRoleUser field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetAssumedRoleUser(v *AssumedRoleUser) *AssumeRoleWithWebIdentityOutput {+ s.AssumedRoleUser = v+ return s+}++// SetAudience sets the Audience field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetAudience(v string) *AssumeRoleWithWebIdentityOutput {+ s.Audience = &v+ return s+}++// SetCredentials sets the Credentials field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetCredentials(v *Credentials) *AssumeRoleWithWebIdentityOutput {+ s.Credentials = v+ return s+}++// SetPackedPolicySize sets the PackedPolicySize field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetPackedPolicySize(v int64) *AssumeRoleWithWebIdentityOutput {+ s.PackedPolicySize = &v+ return s+}++// SetProvider sets the Provider field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetProvider(v string) *AssumeRoleWithWebIdentityOutput {+ s.Provider = &v+ return s+}++// SetSubjectFromWebIdentityToken sets the SubjectFromWebIdentityToken field's value.+func (s *AssumeRoleWithWebIdentityOutput) SetSubjectFromWebIdentityToken(v string) *AssumeRoleWithWebIdentityOutput {+ s.SubjectFromWebIdentityToken = &v+ return s+}++// The identifiers for the temporary security credentials that the operation+// returns.+type AssumedRoleUser struct {+ _ struct{} `type:"structure"`++ // The ARN of the temporary security credentials that are returned from the+ // AssumeRole action. For more information about ARNs and how to use them in+ // policies, see IAM Identifiers (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)+ // in Using IAM.+ //+ // Arn is a required field+ Arn *string `min:"20" type:"string" required:"true"`++ // A unique identifier that contains the role ID and the role session name of+ // the role that is being assumed. The role ID is generated by AWS when the+ // role is created.+ //+ // AssumedRoleId is a required field+ AssumedRoleId *string `min:"2" type:"string" required:"true"`+}++// String returns the string representation+func (s AssumedRoleUser) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s AssumedRoleUser) GoString() string {+ return s.String()+}++// SetArn sets the Arn field's value.+func (s *AssumedRoleUser) SetArn(v string) *AssumedRoleUser {+ s.Arn = &v+ return s+}++// SetAssumedRoleId sets the AssumedRoleId field's value.+func (s *AssumedRoleUser) SetAssumedRoleId(v string) *AssumedRoleUser {+ s.AssumedRoleId = &v+ return s+}++// AWS credentials for API authentication.+type Credentials struct {+ _ struct{} `type:"structure"`++ // The access key ID that identifies the temporary security credentials.+ //+ // AccessKeyId is a required field+ AccessKeyId *string `min:"16" type:"string" required:"true"`++ // The date on which the current credentials expire.+ //+ // Expiration is a required field+ Expiration *time.Time `type:"timestamp" required:"true"`++ // The secret access key that can be used to sign requests.+ //+ // SecretAccessKey is a required field+ SecretAccessKey *string `type:"string" required:"true"`++ // The token that users must pass to the service API to use the temporary credentials.+ //+ // SessionToken is a required field+ SessionToken *string `type:"string" required:"true"`+}++// String returns the string representation+func (s Credentials) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s Credentials) GoString() string {+ return s.String()+}++// SetAccessKeyId sets the AccessKeyId field's value.+func (s *Credentials) SetAccessKeyId(v string) *Credentials {+ s.AccessKeyId = &v+ return s+}++// SetExpiration sets the Expiration field's value.+func (s *Credentials) SetExpiration(v time.Time) *Credentials {+ s.Expiration = &v+ return s+}++// SetSecretAccessKey sets the SecretAccessKey field's value.+func (s *Credentials) SetSecretAccessKey(v string) *Credentials {+ s.SecretAccessKey = &v+ return s+}++// SetSessionToken sets the SessionToken field's value.+func (s *Credentials) SetSessionToken(v string) *Credentials {+ s.SessionToken = &v+ return s+}++type DecodeAuthorizationMessageInput struct {+ _ struct{} `type:"structure"`++ // The encoded message that was returned with the response.+ //+ // EncodedMessage is a required field+ EncodedMessage *string `min:"1" type:"string" required:"true"`+}++// String returns the string representation+func (s DecodeAuthorizationMessageInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DecodeAuthorizationMessageInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *DecodeAuthorizationMessageInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "DecodeAuthorizationMessageInput"}+ if s.EncodedMessage == nil {+ invalidParams.Add(request.NewErrParamRequired("EncodedMessage"))+ }+ if s.EncodedMessage != nil && len(*s.EncodedMessage) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("EncodedMessage", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetEncodedMessage sets the EncodedMessage field's value.+func (s *DecodeAuthorizationMessageInput) SetEncodedMessage(v string) *DecodeAuthorizationMessageInput {+ s.EncodedMessage = &v+ return s+}++// A document that contains additional information about the authorization status+// of a request from an encoded message that is returned in response to an AWS+// request.+type DecodeAuthorizationMessageOutput struct {+ _ struct{} `type:"structure"`++ // An XML document that contains the decoded message.+ DecodedMessage *string `type:"string"`+}++// String returns the string representation+func (s DecodeAuthorizationMessageOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s DecodeAuthorizationMessageOutput) GoString() string {+ return s.String()+}++// SetDecodedMessage sets the DecodedMessage field's value.+func (s *DecodeAuthorizationMessageOutput) SetDecodedMessage(v string) *DecodeAuthorizationMessageOutput {+ s.DecodedMessage = &v+ return s+}++// Identifiers for the federated user that is associated with the credentials.+type FederatedUser struct {+ _ struct{} `type:"structure"`++ // The ARN that specifies the federated user that is associated with the credentials.+ // For more information about ARNs and how to use them in policies, see IAM+ // Identifiers (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)+ // in Using IAM.+ //+ // Arn is a required field+ Arn *string `min:"20" type:"string" required:"true"`++ // The string that identifies the federated user associated with the credentials,+ // similar to the unique ID of an IAM user.+ //+ // FederatedUserId is a required field+ FederatedUserId *string `min:"2" type:"string" required:"true"`+}++// String returns the string representation+func (s FederatedUser) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s FederatedUser) GoString() string {+ return s.String()+}++// SetArn sets the Arn field's value.+func (s *FederatedUser) SetArn(v string) *FederatedUser {+ s.Arn = &v+ return s+}++// SetFederatedUserId sets the FederatedUserId field's value.+func (s *FederatedUser) SetFederatedUserId(v string) *FederatedUser {+ s.FederatedUserId = &v+ return s+}++type GetCallerIdentityInput struct {+ _ struct{} `type:"structure"`+}++// String returns the string representation+func (s GetCallerIdentityInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetCallerIdentityInput) GoString() string {+ return s.String()+}++// Contains the response to a successful GetCallerIdentity request, including+// information about the entity making the request.+type GetCallerIdentityOutput struct {+ _ struct{} `type:"structure"`++ // The AWS account ID number of the account that owns or contains the calling+ // entity.+ Account *string `type:"string"`++ // The AWS ARN associated with the calling entity.+ Arn *string `min:"20" type:"string"`++ // The unique identifier of the calling entity. The exact value depends on the+ // type of entity making the call. The values returned are those listed in the+ // aws:userid column in the Principal table (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable)+ // found on the Policy Variables reference page in the IAM User Guide.+ UserId *string `type:"string"`+}++// String returns the string representation+func (s GetCallerIdentityOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetCallerIdentityOutput) GoString() string {+ return s.String()+}++// SetAccount sets the Account field's value.+func (s *GetCallerIdentityOutput) SetAccount(v string) *GetCallerIdentityOutput {+ s.Account = &v+ return s+}++// SetArn sets the Arn field's value.+func (s *GetCallerIdentityOutput) SetArn(v string) *GetCallerIdentityOutput {+ s.Arn = &v+ return s+}++// SetUserId sets the UserId field's value.+func (s *GetCallerIdentityOutput) SetUserId(v string) *GetCallerIdentityOutput {+ s.UserId = &v+ return s+}++type GetFederationTokenInput struct {+ _ struct{} `type:"structure"`++ // The duration, in seconds, that the session should last. Acceptable durations+ // for federation sessions range from 900 seconds (15 minutes) to 129600 seconds+ // (36 hours), with 43200 seconds (12 hours) as the default. Sessions obtained+ // using AWS account (root) credentials are restricted to a maximum of 3600+ // seconds (one hour). If the specified duration is longer than one hour, the+ // session obtained by using AWS account (root) credentials defaults to one+ // hour.+ DurationSeconds *int64 `min:"900" type:"integer"`++ // The name of the federated user. The name is used as an identifier for the+ // temporary security credentials (such as Bob). For example, you can reference+ // the federated user name in a resource-based policy, such as in an Amazon+ // S3 bucket policy.+ //+ // The regex used to validate this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@-+ //+ // Name is a required field+ Name *string `min:"2" type:"string" required:"true"`++ // An IAM policy in JSON format that is passed with the GetFederationToken call+ // and evaluated along with the policy or policies that are attached to the+ // IAM user whose credentials are used to call GetFederationToken. The passed+ // policy is used to scope down the permissions that are available to the IAM+ // user, by allowing only a subset of the permissions that are granted to the+ // IAM user. The passed policy cannot grant more permissions than those granted+ // to the IAM user. The final permissions for the federated user are the most+ // restrictive set based on the intersection of the passed policy and the IAM+ // user policy.+ //+ // If you do not pass a policy, the resulting temporary security credentials+ // have no effective permissions. The only exception is when the temporary security+ // credentials are used to access a resource that has a resource-based policy+ // that specifically allows the federated user to access the resource.+ //+ // The format for this parameter, as described by its regex pattern, is a string+ // of characters up to 2048 characters in length. The characters can be any+ // ASCII character from the space character to the end of the valid character+ // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),+ // and carriage return (\u000D) characters.+ //+ // The policy plain text must be 2048 bytes or shorter. However, an internal+ // conversion compresses it into a packed binary format with a separate limit.+ // The PackedPolicySize response element indicates by percentage how close to+ // the upper size limit the policy is, with 100% equaling the maximum allowed+ // size.+ //+ // For more information about how permissions work, see Permissions for GetFederationToken+ // (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html).+ Policy *string `min:"1" type:"string"`+}++// String returns the string representation+func (s GetFederationTokenInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetFederationTokenInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetFederationTokenInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetFederationTokenInput"}+ if s.DurationSeconds != nil && *s.DurationSeconds < 900 {+ invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))+ }+ if s.Name == nil {+ invalidParams.Add(request.NewErrParamRequired("Name"))+ }+ if s.Name != nil && len(*s.Name) < 2 {+ invalidParams.Add(request.NewErrParamMinLen("Name", 2))+ }+ if s.Policy != nil && len(*s.Policy) < 1 {+ invalidParams.Add(request.NewErrParamMinLen("Policy", 1))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDurationSeconds sets the DurationSeconds field's value.+func (s *GetFederationTokenInput) SetDurationSeconds(v int64) *GetFederationTokenInput {+ s.DurationSeconds = &v+ return s+}++// SetName sets the Name field's value.+func (s *GetFederationTokenInput) SetName(v string) *GetFederationTokenInput {+ s.Name = &v+ return s+}++// SetPolicy sets the Policy field's value.+func (s *GetFederationTokenInput) SetPolicy(v string) *GetFederationTokenInput {+ s.Policy = &v+ return s+}++// Contains the response to a successful GetFederationToken request, including+// temporary AWS credentials that can be used to make AWS requests.+type GetFederationTokenOutput struct {+ _ struct{} `type:"structure"`++ // The temporary security credentials, which include an access key ID, a secret+ // access key, and a security (or session) token.+ //+ // Note: The size of the security token that STS APIs return is not fixed. We+ // strongly recommend that you make no assumptions about the maximum size. As+ // of this writing, the typical size is less than 4096 bytes, but that can vary.+ // Also, future updates to AWS might require larger sizes.+ Credentials *Credentials `type:"structure"`++ // Identifiers for the federated user associated with the credentials (such+ // as arn:aws:sts::123456789012:federated-user/Bob or 123456789012:Bob). You+ // can use the federated user's ARN in your resource-based policies, such as+ // an Amazon S3 bucket policy.+ FederatedUser *FederatedUser `type:"structure"`++ // A percentage value indicating the size of the policy in packed form. The+ // service rejects policies for which the packed size is greater than 100 percent+ // of the allowed value.+ PackedPolicySize *int64 `type:"integer"`+}++// String returns the string representation+func (s GetFederationTokenOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetFederationTokenOutput) GoString() string {+ return s.String()+}++// SetCredentials sets the Credentials field's value.+func (s *GetFederationTokenOutput) SetCredentials(v *Credentials) *GetFederationTokenOutput {+ s.Credentials = v+ return s+}++// SetFederatedUser sets the FederatedUser field's value.+func (s *GetFederationTokenOutput) SetFederatedUser(v *FederatedUser) *GetFederationTokenOutput {+ s.FederatedUser = v+ return s+}++// SetPackedPolicySize sets the PackedPolicySize field's value.+func (s *GetFederationTokenOutput) SetPackedPolicySize(v int64) *GetFederationTokenOutput {+ s.PackedPolicySize = &v+ return s+}++type GetSessionTokenInput struct {+ _ struct{} `type:"structure"`++ // The duration, in seconds, that the credentials should remain valid. Acceptable+ // durations for IAM user sessions range from 900 seconds (15 minutes) to 129600+ // seconds (36 hours), with 43200 seconds (12 hours) as the default. Sessions+ // for AWS account owners are restricted to a maximum of 3600 seconds (one hour).+ // If the duration is longer than one hour, the session for AWS account owners+ // defaults to one hour.+ DurationSeconds *int64 `min:"900" type:"integer"`++ // The identification number of the MFA device that is associated with the IAM+ // user who is making the GetSessionToken call. Specify this value if the IAM+ // user has a policy that requires MFA authentication. The value is either the+ // serial number for a hardware device (such as GAHT12345678) or an Amazon Resource+ // Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).+ // You can find the device for an IAM user by going to the AWS Management Console+ // and viewing the user's security credentials.+ //+ // The regex used to validated this parameter is a string of characters consisting+ // of upper- and lower-case alphanumeric characters with no spaces. You can+ // also include underscores or any of the following characters: =,.@:/-+ SerialNumber *string `min:"9" type:"string"`++ // The value provided by the MFA device, if MFA is required. If any policy requires+ // the IAM user to submit an MFA code, specify this value. If MFA authentication+ // is required, and the user does not provide a code when requesting a set of+ // temporary security credentials, the user will receive an "access denied"+ // response when requesting resources that require MFA authentication.+ //+ // The format for this parameter, as described by its regex pattern, is a sequence+ // of six numeric digits.+ TokenCode *string `min:"6" type:"string"`+}++// String returns the string representation+func (s GetSessionTokenInput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetSessionTokenInput) GoString() string {+ return s.String()+}++// Validate inspects the fields of the type to determine if they are valid.+func (s *GetSessionTokenInput) Validate() error {+ invalidParams := request.ErrInvalidParams{Context: "GetSessionTokenInput"}+ if s.DurationSeconds != nil && *s.DurationSeconds < 900 {+ invalidParams.Add(request.NewErrParamMinValue("DurationSeconds", 900))+ }+ if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {+ invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))+ }+ if s.TokenCode != nil && len(*s.TokenCode) < 6 {+ invalidParams.Add(request.NewErrParamMinLen("TokenCode", 6))+ }++ if invalidParams.Len() > 0 {+ return invalidParams+ }+ return nil+}++// SetDurationSeconds sets the DurationSeconds field's value.+func (s *GetSessionTokenInput) SetDurationSeconds(v int64) *GetSessionTokenInput {+ s.DurationSeconds = &v+ return s+}++// SetSerialNumber sets the SerialNumber field's value.+func (s *GetSessionTokenInput) SetSerialNumber(v string) *GetSessionTokenInput {+ s.SerialNumber = &v+ return s+}++// SetTokenCode sets the TokenCode field's value.+func (s *GetSessionTokenInput) SetTokenCode(v string) *GetSessionTokenInput {+ s.TokenCode = &v+ return s+}++// Contains the response to a successful GetSessionToken request, including+// temporary AWS credentials that can be used to make AWS requests.+type GetSessionTokenOutput struct {+ _ struct{} `type:"structure"`++ // The temporary security credentials, which include an access key ID, a secret+ // access key, and a security (or session) token.+ //+ // Note: The size of the security token that STS APIs return is not fixed. We+ // strongly recommend that you make no assumptions about the maximum size. As+ // of this writing, the typical size is less than 4096 bytes, but that can vary.+ // Also, future updates to AWS might require larger sizes.+ Credentials *Credentials `type:"structure"`+}++// String returns the string representation+func (s GetSessionTokenOutput) String() string {+ return awsutil.Prettify(s)+}++// GoString returns the string representation+func (s GetSessionTokenOutput) GoString() string {+ return s.String()+}++// SetCredentials sets the Credentials field's value.+func (s *GetSessionTokenOutput) SetCredentials(v *Credentials) *GetSessionTokenOutput {+ s.Credentials = v+ return s+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go b/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.gonew file mode 100644index 000000000..4010cc7fa--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go@@ -0,0 +1,12 @@+package sts++import "github.com/aws/aws-sdk-go/aws/request"++func init() {+ initRequest = func(r *request.Request) {+ switch r.Operation.Name {+ case opAssumeRoleWithSAML, opAssumeRoleWithWebIdentity:+ r.Handlers.Sign.Clear() // these operations are unsigned+ }+ }+}diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/doc.go b/vendor/github.com/aws/aws-sdk-go/service/sts/doc.gonew file mode 100644index 000000000..ef681ab0c--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/doc.go@@ -0,0 +1,72 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++// Package sts provides the client and types for making API+// requests to AWS Security Token Service.+//+// The AWS Security Token Service (STS) is a web service that enables you to+// request temporary, limited-privilege credentials for AWS Identity and Access+// Management (IAM) users or for users that you authenticate (federated users).+// This guide provides descriptions of the STS API. For more detailed information+// about using this service, go to Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html).+//+// As an alternative to using the API, you can use one of the AWS SDKs, which+// consist of libraries and sample code for various programming languages and+// platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient+// way to create programmatic access to STS. For example, the SDKs take care+// of cryptographically signing requests, managing errors, and retrying requests+// automatically. For information about the AWS SDKs, including how to download+// and install them, see the Tools for Amazon Web Services page (http://aws.amazon.com/tools/).+//+// For information about setting up signatures and authorization through the+// API, go to Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)+// in the AWS General Reference. For general information about the Query API,+// go to Making Query Requests (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)+// in Using IAM. For information about using security tokens with other AWS+// products, go to AWS Services That Work with IAM (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)+// in the IAM User Guide.+//+// If you're new to AWS and need additional technical information about a specific+// AWS product, you can find the product's technical documentation at http://aws.amazon.com/documentation/+// (http://aws.amazon.com/documentation/).+//+// Endpoints+//+// The AWS Security Token Service (STS) has a default endpoint of https://sts.amazonaws.com+// that maps to the US East (N. Virginia) region. Additional regions are available+// and are activated by default. For more information, see Activating and Deactivating+// AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+// in the IAM User Guide.+//+// For information about STS endpoints, see Regions and Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#sts_region)+// in the AWS General Reference.+//+// Recording API requests+//+// STS supports AWS CloudTrail, which is a service that records AWS calls for+// your AWS account and delivers log files to an Amazon S3 bucket. By using+// information collected by CloudTrail, you can determine what requests were+// successfully made to STS, who made the request, when it was made, and so+// on. To learn more about CloudTrail, including how to turn it on and find+// your log files, see the AWS CloudTrail User Guide (http://docs.aws.amazon.com/awscloudtrail/latest/userguide/what_is_cloud_trail_top_level.html).+//+// See https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15 for more information on this service.+//+// See sts package documentation for more information.+// https://docs.aws.amazon.com/sdk-for-go/api/service/sts/+//+// Using the Client+//+// To contact AWS Security Token Service with the SDK use the New function to create+// a new service client. With that client you can make API requests to the service.+// These clients are safe to use concurrently.+//+// See the SDK's documentation for more information on how to use the SDK.+// https://docs.aws.amazon.com/sdk-for-go/api/+//+// See aws.Config documentation for more information on configuring SDK clients.+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config+//+// See the AWS Security Token Service client STS for more+// information on creating client for this service.+// https://docs.aws.amazon.com/sdk-for-go/api/service/sts/#New+package stsdiff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/errors.go b/vendor/github.com/aws/aws-sdk-go/service/sts/errors.gonew file mode 100644index 000000000..e24884ef3--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/errors.go@@ -0,0 +1,73 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package sts++const (++ // ErrCodeExpiredTokenException for service response error code+ // "ExpiredTokenException".+ //+ // The web identity token that was passed is expired or is not valid. Get a+ // new identity token from the identity provider and then retry the request.+ ErrCodeExpiredTokenException = "ExpiredTokenException"++ // ErrCodeIDPCommunicationErrorException for service response error code+ // "IDPCommunicationError".+ //+ // The request could not be fulfilled because the non-AWS identity provider+ // (IDP) that was asked to verify the incoming identity token could not be reached.+ // This is often a transient error caused by network conditions. Retry the request+ // a limited number of times so that you don't exceed the request rate. If the+ // error persists, the non-AWS identity provider might be down or not responding.+ ErrCodeIDPCommunicationErrorException = "IDPCommunicationError"++ // ErrCodeIDPRejectedClaimException for service response error code+ // "IDPRejectedClaim".+ //+ // The identity provider (IdP) reported that authentication failed. This might+ // be because the claim is invalid.+ //+ // If this error is returned for the AssumeRoleWithWebIdentity operation, it+ // can also mean that the claim has expired or has been explicitly revoked.+ ErrCodeIDPRejectedClaimException = "IDPRejectedClaim"++ // ErrCodeInvalidAuthorizationMessageException for service response error code+ // "InvalidAuthorizationMessageException".+ //+ // The error returned if the message passed to DecodeAuthorizationMessage was+ // invalid. This can happen if the token contains invalid characters, such as+ // linebreaks.+ ErrCodeInvalidAuthorizationMessageException = "InvalidAuthorizationMessageException"++ // ErrCodeInvalidIdentityTokenException for service response error code+ // "InvalidIdentityToken".+ //+ // The web identity token that was passed could not be validated by AWS. Get+ // a new identity token from the identity provider and then retry the request.+ ErrCodeInvalidIdentityTokenException = "InvalidIdentityToken"++ // ErrCodeMalformedPolicyDocumentException for service response error code+ // "MalformedPolicyDocument".+ //+ // The request was rejected because the policy document was malformed. The error+ // message describes the specific error.+ ErrCodeMalformedPolicyDocumentException = "MalformedPolicyDocument"++ // ErrCodePackedPolicyTooLargeException for service response error code+ // "PackedPolicyTooLarge".+ //+ // The request was rejected because the policy document was too large. The error+ // message describes how big the policy document is, in packed form, as a percentage+ // of what the API allows.+ ErrCodePackedPolicyTooLargeException = "PackedPolicyTooLarge"++ // ErrCodeRegionDisabledException for service response error code+ // "RegionDisabledException".+ //+ // STS is not activated in the requested region for the account that is being+ // asked to generate credentials. The account administrator must use the IAM+ // console to activate STS in that region. For more information, see Activating+ // and Deactivating AWS STS in an AWS Region (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)+ // in the IAM User Guide.+ ErrCodeRegionDisabledException = "RegionDisabledException"+)diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/service.go b/vendor/github.com/aws/aws-sdk-go/service/sts/service.gonew file mode 100644index 000000000..185c914d1--- /dev/null+++ b/vendor/github.com/aws/aws-sdk-go/service/sts/service.go@@ -0,0 +1,95 @@+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.++package sts++import (+ "github.com/aws/aws-sdk-go/aws"+ "github.com/aws/aws-sdk-go/aws/client"+ "github.com/aws/aws-sdk-go/aws/client/metadata"+ "github.com/aws/aws-sdk-go/aws/request"+ "github.com/aws/aws-sdk-go/aws/signer/v4"+ "github.com/aws/aws-sdk-go/private/protocol/query"+)++// STS provides the API operation methods for making requests to+// AWS Security Token Service. See this package's package overview docs+// for details on the service.+//+// STS methods are safe to use concurrently. It is not safe to+// modify mutate any of the struct's properties though.+type STS struct {+ *client.Client+}++// Used for custom client initialization logic+var initClient func(*client.Client)++// Used for custom request initialization logic+var initRequest func(*request.Request)++// Service information constants+const (+ ServiceName = "sts" // Name of service.+ EndpointsID = ServiceName // ID to lookup a service endpoint with.+ ServiceID = "STS" // ServiceID is a unique identifer of a specific service.+)++// New creates a new instance of the STS client with a session.+// If additional configuration is needed for the client instance use the optional+// aws.Config parameter to add your extra config.+//+// Example:+// // Create a STS client from just a session.+// svc := sts.New(mySession)+//+// // Create a STS client with additional configuration+// svc := sts.New(mySession, aws.NewConfig().WithRegion("us-west-2"))+func New(p client.ConfigProvider, cfgs ...*aws.Config) *STS {+ c := p.ClientConfig(EndpointsID, cfgs...)+ return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName)+}++// newClient creates, initializes and returns a new service client instance.+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *STS {+ svc := &STS{+ Client: client.New(+ cfg,+ metadata.ClientInfo{+ ServiceName: ServiceName,+ ServiceID: ServiceID,+ SigningName: signingName,+ SigningRegion: signingRegion,+ Endpoint: endpoint,+ APIVersion: "2011-06-15",+ },+ handlers,+ ),+ }++ // Handlers+ svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)+ svc.Handlers.Build.PushBackNamed(query.BuildHandler)+ svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler)+ svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler)+ svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler)++ // Run custom client initialization if present+ if initClient != nil {+ initClient(svc.Client)+ }++ return svc+}++// newRequest creates a new request for a STS operation and runs any+// custom request initialization.+func (c *STS) newRequest(op *request.Operation, params, data interface{}) *request.Request {+ req := c.NewRequest(op, params, data)++ // Run custom request initialization if present+ if initRequest != nil {+ initRequest(req)+ }++ return req+}diff --git a/vendor/github.com/jmespath/go-jmespath/.gitignore b/vendor/github.com/jmespath/go-jmespath/.gitignorenew file mode 100644index 000000000..5091fb073--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/.gitignore@@ -0,0 +1,4 @@+/jpgo+jmespath-fuzz.zip+cpu.out+go-jmespath.testdiff --git a/vendor/github.com/jmespath/go-jmespath/.travis.yml b/vendor/github.com/jmespath/go-jmespath/.travis.ymlnew file mode 100644index 000000000..1f9807757--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/.travis.yml@@ -0,0 +1,9 @@+language: go++sudo: false++go:+ - 1.4++install: go get -v -t ./...+script: make testdiff --git a/vendor/github.com/jmespath/go-jmespath/LICENSE b/vendor/github.com/jmespath/go-jmespath/LICENSEnew file mode 100644index 000000000..b03310a91--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/LICENSE@@ -0,0 +1,13 @@+Copyright 2015 James Saryerwinnie++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.diff --git a/vendor/github.com/jmespath/go-jmespath/Makefile b/vendor/github.com/jmespath/go-jmespath/Makefilenew file mode 100644index 000000000..a828d2848--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/Makefile@@ -0,0 +1,44 @@++CMD = jpgo++help:+ @echo "Please use \`make <target>' where <target> is one of"+ @echo " test to run all the tests"+ @echo " build to build the library and jp executable"+ @echo " generate to run codegen"+++generate:+ go generate ./...++build:+ rm -f $(CMD)+ go build ./...+ rm -f cmd/$(CMD)/$(CMD) && cd cmd/$(CMD)/ && go build ./...+ mv cmd/$(CMD)/$(CMD) .++test:+ go test -v ./...++check:+ go vet ./...+ @echo "golint ./..."+ @lint=`golint ./...`; \+ lint=`echo "$$lint" | grep -v "astnodetype_string.go" | grep -v "toktype_string.go"`; \+ echo "$$lint"; \+ if [ "$$lint" != "" ]; then exit 1; fi++htmlc:+ go test -coverprofile="/tmp/jpcov" && go tool cover -html="/tmp/jpcov" && unlink /tmp/jpcov++buildfuzz:+ go-fuzz-build github.com/jmespath/go-jmespath/fuzz++fuzz: buildfuzz+ go-fuzz -bin=./jmespath-fuzz.zip -workdir=fuzz/testdata++bench:+ go test -bench . -cpuprofile cpu.out++pprof-cpu:+ go tool pprof ./go-jmespath.test ./cpu.outdiff --git a/vendor/github.com/jmespath/go-jmespath/README.md b/vendor/github.com/jmespath/go-jmespath/README.mdnew file mode 100644index 000000000..187ef676d--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/README.md@@ -0,0 +1,7 @@+# go-jmespath - A JMESPath implementation in Go++[](https://travis-ci.org/jmespath/go-jmespath)++++See http://jmespath.org for more info.diff --git a/vendor/github.com/jmespath/go-jmespath/api.go b/vendor/github.com/jmespath/go-jmespath/api.gonew file mode 100644index 000000000..8e26ffeec--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/api.go@@ -0,0 +1,49 @@+package jmespath++import "strconv"++// JMESPath is the epresentation of a compiled JMES path query. A JMESPath is+// safe for concurrent use by multiple goroutines.+type JMESPath struct {+ ast ASTNode+ intr *treeInterpreter+}++// Compile parses a JMESPath expression and returns, if successful, a JMESPath+// object that can be used to match against data.+func Compile(expression string) (*JMESPath, error) {+ parser := NewParser()+ ast, err := parser.Parse(expression)+ if err != nil {+ return nil, err+ }+ jmespath := &JMESPath{ast: ast, intr: newInterpreter()}+ return jmespath, nil+}++// MustCompile is like Compile but panics if the expression cannot be parsed.+// It simplifies safe initialization of global variables holding compiled+// JMESPaths.+func MustCompile(expression string) *JMESPath {+ jmespath, err := Compile(expression)+ if err != nil {+ panic(`jmespath: Compile(` + strconv.Quote(expression) + `): ` + err.Error())+ }+ return jmespath+}++// Search evaluates a JMESPath expression against input data and returns the result.+func (jp *JMESPath) Search(data interface{}) (interface{}, error) {+ return jp.intr.Execute(jp.ast, data)+}++// Search evaluates a JMESPath expression against input data and returns the result.+func Search(expression string, data interface{}) (interface{}, error) {+ intr := newInterpreter()+ parser := NewParser()+ ast, err := parser.Parse(expression)+ if err != nil {+ return nil, err+ }+ return intr.Execute(ast, data)+}diff --git a/vendor/github.com/jmespath/go-jmespath/astnodetype_string.go b/vendor/github.com/jmespath/go-jmespath/astnodetype_string.gonew file mode 100644index 000000000..1cd2d239c--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/astnodetype_string.go@@ -0,0 +1,16 @@+// generated by stringer -type astNodeType; DO NOT EDIT++package jmespath++import "fmt"++const _astNodeType_name = "ASTEmptyASTComparatorASTCurrentNodeASTExpRefASTFunctionExpressionASTFieldASTFilterProjectionASTFlattenASTIdentityASTIndexASTIndexExpressionASTKeyValPairASTLiteralASTMultiSelectHashASTMultiSelectListASTOrExpressionASTAndExpressionASTNotExpressionASTPipeASTProjectionASTSubexpressionASTSliceASTValueProjection"++var _astNodeType_index = [...]uint16{0, 8, 21, 35, 44, 65, 73, 92, 102, 113, 121, 139, 152, 162, 180, 198, 213, 229, 245, 252, 265, 281, 289, 307}++func (i astNodeType) String() string {+ if i < 0 || i >= astNodeType(len(_astNodeType_index)-1) {+ return fmt.Sprintf("astNodeType(%d)", i)+ }+ return _astNodeType_name[_astNodeType_index[i]:_astNodeType_index[i+1]]+}diff --git a/vendor/github.com/jmespath/go-jmespath/functions.go b/vendor/github.com/jmespath/go-jmespath/functions.gonew file mode 100644index 000000000..9b7cd89b4--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/functions.go@@ -0,0 +1,842 @@+package jmespath++import (+ "encoding/json"+ "errors"+ "fmt"+ "math"+ "reflect"+ "sort"+ "strconv"+ "strings"+ "unicode/utf8"+)++type jpFunction func(arguments []interface{}) (interface{}, error)++type jpType string++const (+ jpUnknown jpType = "unknown"+ jpNumber jpType = "number"+ jpString jpType = "string"+ jpArray jpType = "array"+ jpObject jpType = "object"+ jpArrayNumber jpType = "array[number]"+ jpArrayString jpType = "array[string]"+ jpExpref jpType = "expref"+ jpAny jpType = "any"+)++type functionEntry struct {+ name string+ arguments []argSpec+ handler jpFunction+ hasExpRef bool+}++type argSpec struct {+ types []jpType+ variadic bool+}++type byExprString struct {+ intr *treeInterpreter+ node ASTNode+ items []interface{}+ hasError bool+}++func (a *byExprString) Len() int {+ return len(a.items)+}+func (a *byExprString) Swap(i, j int) {+ a.items[i], a.items[j] = a.items[j], a.items[i]+}+func (a *byExprString) Less(i, j int) bool {+ first, err := a.intr.Execute(a.node, a.items[i])+ if err != nil {+ a.hasError = true+ // Return a dummy value.+ return true+ }+ ith, ok := first.(string)+ if !ok {+ a.hasError = true+ return true+ }+ second, err := a.intr.Execute(a.node, a.items[j])+ if err != nil {+ a.hasError = true+ // Return a dummy value.+ return true+ }+ jth, ok := second.(string)+ if !ok {+ a.hasError = true+ return true+ }+ return ith < jth+}++type byExprFloat struct {+ intr *treeInterpreter+ node ASTNode+ items []interface{}+ hasError bool+}++func (a *byExprFloat) Len() int {+ return len(a.items)+}+func (a *byExprFloat) Swap(i, j int) {+ a.items[i], a.items[j] = a.items[j], a.items[i]+}+func (a *byExprFloat) Less(i, j int) bool {+ first, err := a.intr.Execute(a.node, a.items[i])+ if err != nil {+ a.hasError = true+ // Return a dummy value.+ return true+ }+ ith, ok := first.(float64)+ if !ok {+ a.hasError = true+ return true+ }+ second, err := a.intr.Execute(a.node, a.items[j])+ if err != nil {+ a.hasError = true+ // Return a dummy value.+ return true+ }+ jth, ok := second.(float64)+ if !ok {+ a.hasError = true+ return true+ }+ return ith < jth+}++type functionCaller struct {+ functionTable map[string]functionEntry+}++func newFunctionCaller() *functionCaller {+ caller := &functionCaller{}+ caller.functionTable = map[string]functionEntry{+ "length": {+ name: "length",+ arguments: []argSpec{+ {types: []jpType{jpString, jpArray, jpObject}},+ },+ handler: jpfLength,+ },+ "starts_with": {+ name: "starts_with",+ arguments: []argSpec{+ {types: []jpType{jpString}},+ {types: []jpType{jpString}},+ },+ handler: jpfStartsWith,+ },+ "abs": {+ name: "abs",+ arguments: []argSpec{+ {types: []jpType{jpNumber}},+ },+ handler: jpfAbs,+ },+ "avg": {+ name: "avg",+ arguments: []argSpec{+ {types: []jpType{jpArrayNumber}},+ },+ handler: jpfAvg,+ },+ "ceil": {+ name: "ceil",+ arguments: []argSpec{+ {types: []jpType{jpNumber}},+ },+ handler: jpfCeil,+ },+ "contains": {+ name: "contains",+ arguments: []argSpec{+ {types: []jpType{jpArray, jpString}},+ {types: []jpType{jpAny}},+ },+ handler: jpfContains,+ },+ "ends_with": {+ name: "ends_with",+ arguments: []argSpec{+ {types: []jpType{jpString}},+ {types: []jpType{jpString}},+ },+ handler: jpfEndsWith,+ },+ "floor": {+ name: "floor",+ arguments: []argSpec{+ {types: []jpType{jpNumber}},+ },+ handler: jpfFloor,+ },+ "map": {+ name: "amp",+ arguments: []argSpec{+ {types: []jpType{jpExpref}},+ {types: []jpType{jpArray}},+ },+ handler: jpfMap,+ hasExpRef: true,+ },+ "max": {+ name: "max",+ arguments: []argSpec{+ {types: []jpType{jpArrayNumber, jpArrayString}},+ },+ handler: jpfMax,+ },+ "merge": {+ name: "merge",+ arguments: []argSpec{+ {types: []jpType{jpObject}, variadic: true},+ },+ handler: jpfMerge,+ },+ "max_by": {+ name: "max_by",+ arguments: []argSpec{+ {types: []jpType{jpArray}},+ {types: []jpType{jpExpref}},+ },+ handler: jpfMaxBy,+ hasExpRef: true,+ },+ "sum": {+ name: "sum",+ arguments: []argSpec{+ {types: []jpType{jpArrayNumber}},+ },+ handler: jpfSum,+ },+ "min": {+ name: "min",+ arguments: []argSpec{+ {types: []jpType{jpArrayNumber, jpArrayString}},+ },+ handler: jpfMin,+ },+ "min_by": {+ name: "min_by",+ arguments: []argSpec{+ {types: []jpType{jpArray}},+ {types: []jpType{jpExpref}},+ },+ handler: jpfMinBy,+ hasExpRef: true,+ },+ "type": {+ name: "type",+ arguments: []argSpec{+ {types: []jpType{jpAny}},+ },+ handler: jpfType,+ },+ "keys": {+ name: "keys",+ arguments: []argSpec{+ {types: []jpType{jpObject}},+ },+ handler: jpfKeys,+ },+ "values": {+ name: "values",+ arguments: []argSpec{+ {types: []jpType{jpObject}},+ },+ handler: jpfValues,+ },+ "sort": {+ name: "sort",+ arguments: []argSpec{+ {types: []jpType{jpArrayString, jpArrayNumber}},+ },+ handler: jpfSort,+ },+ "sort_by": {+ name: "sort_by",+ arguments: []argSpec{+ {types: []jpType{jpArray}},+ {types: []jpType{jpExpref}},+ },+ handler: jpfSortBy,+ hasExpRef: true,+ },+ "join": {+ name: "join",+ arguments: []argSpec{+ {types: []jpType{jpString}},+ {types: []jpType{jpArrayString}},+ },+ handler: jpfJoin,+ },+ "reverse": {+ name: "reverse",+ arguments: []argSpec{+ {types: []jpType{jpArray, jpString}},+ },+ handler: jpfReverse,+ },+ "to_array": {+ name: "to_array",+ arguments: []argSpec{+ {types: []jpType{jpAny}},+ },+ handler: jpfToArray,+ },+ "to_string": {+ name: "to_string",+ arguments: []argSpec{+ {types: []jpType{jpAny}},+ },+ handler: jpfToString,+ },+ "to_number": {+ name: "to_number",+ arguments: []argSpec{+ {types: []jpType{jpAny}},+ },+ handler: jpfToNumber,+ },+ "not_null": {+ name: "not_null",+ arguments: []argSpec{+ {types: []jpType{jpAny}, variadic: true},+ },+ handler: jpfNotNull,+ },+ }+ return caller+}++func (e *functionEntry) resolveArgs(arguments []interface{}) ([]interface{}, error) {+ if len(e.arguments) == 0 {+ return arguments, nil+ }+ if !e.arguments[len(e.arguments)-1].variadic {+ if len(e.arguments) != len(arguments) {+ return nil, errors.New("incorrect number of args")+ }+ for i, spec := range e.arguments {+ userArg := arguments[i]+ err := spec.typeCheck(userArg)+ if err != nil {+ return nil, err+ }+ }+ return arguments, nil+ }+ if len(arguments) < len(e.arguments) {+ return nil, errors.New("Invalid arity.")+ }+ return arguments, nil+}++func (a *argSpec) typeCheck(arg interface{}) error {+ for _, t := range a.types {+ switch t {+ case jpNumber:+ if _, ok := arg.(float64); ok {+ return nil+ }+ case jpString:+ if _, ok := arg.(string); ok {+ return nil+ }+ case jpArray:+ if isSliceType(arg) {+ return nil+ }+ case jpObject:+ if _, ok := arg.(map[string]interface{}); ok {+ return nil+ }+ case jpArrayNumber:+ if _, ok := toArrayNum(arg); ok {+ return nil+ }+ case jpArrayString:+ if _, ok := toArrayStr(arg); ok {+ return nil+ }+ case jpAny:+ return nil+ case jpExpref:+ if _, ok := arg.(expRef); ok {+ return nil+ }+ }+ }+ return fmt.Errorf("Invalid type for: %v, expected: %#v", arg, a.types)+}++func (f *functionCaller) CallFunction(name string, arguments []interface{}, intr *treeInterpreter) (interface{}, error) {+ entry, ok := f.functionTable[name]+ if !ok {+ return nil, errors.New("unknown function: " + name)+ }+ resolvedArgs, err := entry.resolveArgs(arguments)+ if err != nil {+ return nil, err+ }+ if entry.hasExpRef {+ var extra []interface{}+ extra = append(extra, intr)+ resolvedArgs = append(extra, resolvedArgs...)+ }+ return entry.handler(resolvedArgs)+}++func jpfAbs(arguments []interface{}) (interface{}, error) {+ num := arguments[0].(float64)+ return math.Abs(num), nil+}++func jpfLength(arguments []interface{}) (interface{}, error) {+ arg := arguments[0]+ if c, ok := arg.(string); ok {+ return float64(utf8.RuneCountInString(c)), nil+ } else if isSliceType(arg) {+ v := reflect.ValueOf(arg)+ return float64(v.Len()), nil+ } else if c, ok := arg.(map[string]interface{}); ok {+ return float64(len(c)), nil+ }+ return nil, errors.New("could not compute length()")+}++func jpfStartsWith(arguments []interface{}) (interface{}, error) {+ search := arguments[0].(string)+ prefix := arguments[1].(string)+ return strings.HasPrefix(search, prefix), nil+}++func jpfAvg(arguments []interface{}) (interface{}, error) {+ // We've already type checked the value so we can safely use+ // type assertions.+ args := arguments[0].([]interface{})+ length := float64(len(args))+ numerator := 0.0+ for _, n := range args {+ numerator += n.(float64)+ }+ return numerator / length, nil+}+func jpfCeil(arguments []interface{}) (interface{}, error) {+ val := arguments[0].(float64)+ return math.Ceil(val), nil+}+func jpfContains(arguments []interface{}) (interface{}, error) {+ search := arguments[0]+ el := arguments[1]+ if searchStr, ok := search.(string); ok {+ if elStr, ok := el.(string); ok {+ return strings.Index(searchStr, elStr) != -1, nil+ }+ return false, nil+ }+ // Otherwise this is a generic contains for []interface{}+ general := search.([]interface{})+ for _, item := range general {+ if item == el {+ return true, nil+ }+ }+ return false, nil+}+func jpfEndsWith(arguments []interface{}) (interface{}, error) {+ search := arguments[0].(string)+ suffix := arguments[1].(string)+ return strings.HasSuffix(search, suffix), nil+}+func jpfFloor(arguments []interface{}) (interface{}, error) {+ val := arguments[0].(float64)+ return math.Floor(val), nil+}+func jpfMap(arguments []interface{}) (interface{}, error) {+ intr := arguments[0].(*treeInterpreter)+ exp := arguments[1].(expRef)+ node := exp.ref+ arr := arguments[2].([]interface{})+ mapped := make([]interface{}, 0, len(arr))+ for _, value := range arr {+ current, err := intr.Execute(node, value)+ if err != nil {+ return nil, err+ }+ mapped = append(mapped, current)+ }+ return mapped, nil+}+func jpfMax(arguments []interface{}) (interface{}, error) {+ if items, ok := toArrayNum(arguments[0]); ok {+ if len(items) == 0 {+ return nil, nil+ }+ if len(items) == 1 {+ return items[0], nil+ }+ best := items[0]+ for _, item := range items[1:] {+ if item > best {+ best = item+ }+ }+ return best, nil+ }+ // Otherwise we're dealing with a max() of strings.+ items, _ := toArrayStr(arguments[0])+ if len(items) == 0 {+ return nil, nil+ }+ if len(items) == 1 {+ return items[0], nil+ }+ best := items[0]+ for _, item := range items[1:] {+ if item > best {+ best = item+ }+ }+ return best, nil+}+func jpfMerge(arguments []interface{}) (interface{}, error) {+ final := make(map[string]interface{})+ for _, m := range arguments {+ mapped := m.(map[string]interface{})+ for key, value := range mapped {+ final[key] = value+ }+ }+ return final, nil+}+func jpfMaxBy(arguments []interface{}) (interface{}, error) {+ intr := arguments[0].(*treeInterpreter)+ arr := arguments[1].([]interface{})+ exp := arguments[2].(expRef)+ node := exp.ref+ if len(arr) == 0 {+ return nil, nil+ } else if len(arr) == 1 {+ return arr[0], nil+ }+ start, err := intr.Execute(node, arr[0])+ if err != nil {+ return nil, err+ }+ switch t := start.(type) {+ case float64:+ bestVal := t+ bestItem := arr[0]+ for _, item := range arr[1:] {+ result, err := intr.Execute(node, item)+ if err != nil {+ return nil, err+ }+ current, ok := result.(float64)+ if !ok {+ return nil, errors.New("invalid type, must be number")+ }+ if current > bestVal {+ bestVal = current+ bestItem = item+ }+ }+ return bestItem, nil+ case string:+ bestVal := t+ bestItem := arr[0]+ for _, item := range arr[1:] {+ result, err := intr.Execute(node, item)+ if err != nil {+ return nil, err+ }+ current, ok := result.(string)+ if !ok {+ return nil, errors.New("invalid type, must be string")+ }+ if current > bestVal {+ bestVal = current+ bestItem = item+ }+ }+ return bestItem, nil+ default:+ return nil, errors.New("invalid type, must be number of string")+ }+}+func jpfSum(arguments []interface{}) (interface{}, error) {+ items, _ := toArrayNum(arguments[0])+ sum := 0.0+ for _, item := range items {+ sum += item+ }+ return sum, nil+}++func jpfMin(arguments []interface{}) (interface{}, error) {+ if items, ok := toArrayNum(arguments[0]); ok {+ if len(items) == 0 {+ return nil, nil+ }+ if len(items) == 1 {+ return items[0], nil+ }+ best := items[0]+ for _, item := range items[1:] {+ if item < best {+ best = item+ }+ }+ return best, nil+ }+ items, _ := toArrayStr(arguments[0])+ if len(items) == 0 {+ return nil, nil+ }+ if len(items) == 1 {+ return items[0], nil+ }+ best := items[0]+ for _, item := range items[1:] {+ if item < best {+ best = item+ }+ }+ return best, nil+}++func jpfMinBy(arguments []interface{}) (interface{}, error) {+ intr := arguments[0].(*treeInterpreter)+ arr := arguments[1].([]interface{})+ exp := arguments[2].(expRef)+ node := exp.ref+ if len(arr) == 0 {+ return nil, nil+ } else if len(arr) == 1 {+ return arr[0], nil+ }+ start, err := intr.Execute(node, arr[0])+ if err != nil {+ return nil, err+ }+ if t, ok := start.(float64); ok {+ bestVal := t+ bestItem := arr[0]+ for _, item := range arr[1:] {+ result, err := intr.Execute(node, item)+ if err != nil {+ return nil, err+ }+ current, ok := result.(float64)+ if !ok {+ return nil, errors.New("invalid type, must be number")+ }+ if current < bestVal {+ bestVal = current+ bestItem = item+ }+ }+ return bestItem, nil+ } else if t, ok := start.(string); ok {+ bestVal := t+ bestItem := arr[0]+ for _, item := range arr[1:] {+ result, err := intr.Execute(node, item)+ if err != nil {+ return nil, err+ }+ current, ok := result.(string)+ if !ok {+ return nil, errors.New("invalid type, must be string")+ }+ if current < bestVal {+ bestVal = current+ bestItem = item+ }+ }+ return bestItem, nil+ } else {+ return nil, errors.New("invalid type, must be number of string")+ }+}+func jpfType(arguments []interface{}) (interface{}, error) {+ arg := arguments[0]+ if _, ok := arg.(float64); ok {+ return "number", nil+ }+ if _, ok := arg.(string); ok {+ return "string", nil+ }+ if _, ok := arg.([]interface{}); ok {+ return "array", nil+ }+ if _, ok := arg.(map[string]interface{}); ok {+ return "object", nil+ }+ if arg == nil {+ return "null", nil+ }+ if arg == true || arg == false {+ return "boolean", nil+ }+ return nil, errors.New("unknown type")+}+func jpfKeys(arguments []interface{}) (interface{}, error) {+ arg := arguments[0].(map[string]interface{})+ collected := make([]interface{}, 0, len(arg))+ for key := range arg {+ collected = append(collected, key)+ }+ return collected, nil+}+func jpfValues(arguments []interface{}) (interface{}, error) {+ arg := arguments[0].(map[string]interface{})+ collected := make([]interface{}, 0, len(arg))+ for _, value := range arg {+ collected = append(collected, value)+ }+ return collected, nil+}+func jpfSort(arguments []interface{}) (interface{}, error) {+ if items, ok := toArrayNum(arguments[0]); ok {+ d := sort.Float64Slice(items)+ sort.Stable(d)+ final := make([]interface{}, len(d))+ for i, val := range d {+ final[i] = val+ }+ return final, nil+ }+ // Otherwise we're dealing with sort()'ing strings.+ items, _ := toArrayStr(arguments[0])+ d := sort.StringSlice(items)+ sort.Stable(d)+ final := make([]interface{}, len(d))+ for i, val := range d {+ final[i] = val+ }+ return final, nil+}+func jpfSortBy(arguments []interface{}) (interface{}, error) {+ intr := arguments[0].(*treeInterpreter)+ arr := arguments[1].([]interface{})+ exp := arguments[2].(expRef)+ node := exp.ref+ if len(arr) == 0 {+ return arr, nil+ } else if len(arr) == 1 {+ return arr, nil+ }+ start, err := intr.Execute(node, arr[0])+ if err != nil {+ return nil, err+ }+ if _, ok := start.(float64); ok {+ sortable := &byExprFloat{intr, node, arr, false}+ sort.Stable(sortable)+ if sortable.hasError {+ return nil, errors.New("error in sort_by comparison")+ }+ return arr, nil+ } else if _, ok := start.(string); ok {+ sortable := &byExprString{intr, node, arr, false}+ sort.Stable(sortable)+ if sortable.hasError {+ return nil, errors.New("error in sort_by comparison")+ }+ return arr, nil+ } else {+ return nil, errors.New("invalid type, must be number of string")+ }+}+func jpfJoin(arguments []interface{}) (interface{}, error) {+ sep := arguments[0].(string)+ // We can't just do arguments[1].([]string), we have to+ // manually convert each item to a string.+ arrayStr := []string{}+ for _, item := range arguments[1].([]interface{}) {+ arrayStr = append(arrayStr, item.(string))+ }+ return strings.Join(arrayStr, sep), nil+}+func jpfReverse(arguments []interface{}) (interface{}, error) {+ if s, ok := arguments[0].(string); ok {+ r := []rune(s)+ for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {+ r[i], r[j] = r[j], r[i]+ }+ return string(r), nil+ }+ items := arguments[0].([]interface{})+ length := len(items)+ reversed := make([]interface{}, length)+ for i, item := range items {+ reversed[length-(i+1)] = item+ }+ return reversed, nil+}+func jpfToArray(arguments []interface{}) (interface{}, error) {+ if _, ok := arguments[0].([]interface{}); ok {+ return arguments[0], nil+ }+ return arguments[:1:1], nil+}+func jpfToString(arguments []interface{}) (interface{}, error) {+ if v, ok := arguments[0].(string); ok {+ return v, nil+ }+ result, err := json.Marshal(arguments[0])+ if err != nil {+ return nil, err+ }+ return string(result), nil+}+func jpfToNumber(arguments []interface{}) (interface{}, error) {+ arg := arguments[0]+ if v, ok := arg.(float64); ok {+ return v, nil+ }+ if v, ok := arg.(string); ok {+ conv, err := strconv.ParseFloat(v, 64)+ if err != nil {+ return nil, nil+ }+ return conv, nil+ }+ if _, ok := arg.([]interface{}); ok {+ return nil, nil+ }+ if _, ok := arg.(map[string]interface{}); ok {+ return nil, nil+ }+ if arg == nil {+ return nil, nil+ }+ if arg == true || arg == false {+ return nil, nil+ }+ return nil, errors.New("unknown type")+}+func jpfNotNull(arguments []interface{}) (interface{}, error) {+ for _, arg := range arguments {+ if arg != nil {+ return arg, nil+ }+ }+ return nil, nil+}diff --git a/vendor/github.com/jmespath/go-jmespath/interpreter.go b/vendor/github.com/jmespath/go-jmespath/interpreter.gonew file mode 100644index 000000000..13c74604c--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/interpreter.go@@ -0,0 +1,418 @@+package jmespath++import (+ "errors"+ "reflect"+ "unicode"+ "unicode/utf8"+)++/* This is a tree based interpreter. It walks the AST and directly+ interprets the AST to search through a JSON document.+*/++type treeInterpreter struct {+ fCall *functionCaller+}++func newInterpreter() *treeInterpreter {+ interpreter := treeInterpreter{}+ interpreter.fCall = newFunctionCaller()+ return &interpreter+}++type expRef struct {+ ref ASTNode+}++// Execute takes an ASTNode and input data and interprets the AST directly.+// It will produce the result of applying the JMESPath expression associated+// with the ASTNode to the input data "value".+func (intr *treeInterpreter) Execute(node ASTNode, value interface{}) (interface{}, error) {+ switch node.nodeType {+ case ASTComparator:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ right, err := intr.Execute(node.children[1], value)+ if err != nil {+ return nil, err+ }+ switch node.value {+ case tEQ:+ return objsEqual(left, right), nil+ case tNE:+ return !objsEqual(left, right), nil+ }+ leftNum, ok := left.(float64)+ if !ok {+ return nil, nil+ }+ rightNum, ok := right.(float64)+ if !ok {+ return nil, nil+ }+ switch node.value {+ case tGT:+ return leftNum > rightNum, nil+ case tGTE:+ return leftNum >= rightNum, nil+ case tLT:+ return leftNum < rightNum, nil+ case tLTE:+ return leftNum <= rightNum, nil+ }+ case ASTExpRef:+ return expRef{ref: node.children[0]}, nil+ case ASTFunctionExpression:+ resolvedArgs := []interface{}{}+ for _, arg := range node.children {+ current, err := intr.Execute(arg, value)+ if err != nil {+ return nil, err+ }+ resolvedArgs = append(resolvedArgs, current)+ }+ return intr.fCall.CallFunction(node.value.(string), resolvedArgs, intr)+ case ASTField:+ if m, ok := value.(map[string]interface{}); ok {+ key := node.value.(string)+ return m[key], nil+ }+ return intr.fieldFromStruct(node.value.(string), value)+ case ASTFilterProjection:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, nil+ }+ sliceType, ok := left.([]interface{})+ if !ok {+ if isSliceType(left) {+ return intr.filterProjectionWithReflection(node, left)+ }+ return nil, nil+ }+ compareNode := node.children[2]+ collected := []interface{}{}+ for _, element := range sliceType {+ result, err := intr.Execute(compareNode, element)+ if err != nil {+ return nil, err+ }+ if !isFalse(result) {+ current, err := intr.Execute(node.children[1], element)+ if err != nil {+ return nil, err+ }+ if current != nil {+ collected = append(collected, current)+ }+ }+ }+ return collected, nil+ case ASTFlatten:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, nil+ }+ sliceType, ok := left.([]interface{})+ if !ok {+ // If we can't type convert to []interface{}, there's+ // a chance this could still work via reflection if we're+ // dealing with user provided types.+ if isSliceType(left) {+ return intr.flattenWithReflection(left)+ }+ return nil, nil+ }+ flattened := []interface{}{}+ for _, element := range sliceType {+ if elementSlice, ok := element.([]interface{}); ok {+ flattened = append(flattened, elementSlice...)+ } else if isSliceType(element) {+ reflectFlat := []interface{}{}+ v := reflect.ValueOf(element)+ for i := 0; i < v.Len(); i++ {+ reflectFlat = append(reflectFlat, v.Index(i).Interface())+ }+ flattened = append(flattened, reflectFlat...)+ } else {+ flattened = append(flattened, element)+ }+ }+ return flattened, nil+ case ASTIdentity, ASTCurrentNode:+ return value, nil+ case ASTIndex:+ if sliceType, ok := value.([]interface{}); ok {+ index := node.value.(int)+ if index < 0 {+ index += len(sliceType)+ }+ if index < len(sliceType) && index >= 0 {+ return sliceType[index], nil+ }+ return nil, nil+ }+ // Otherwise try via reflection.+ rv := reflect.ValueOf(value)+ if rv.Kind() == reflect.Slice {+ index := node.value.(int)+ if index < 0 {+ index += rv.Len()+ }+ if index < rv.Len() && index >= 0 {+ v := rv.Index(index)+ return v.Interface(), nil+ }+ }+ return nil, nil+ case ASTKeyValPair:+ return intr.Execute(node.children[0], value)+ case ASTLiteral:+ return node.value, nil+ case ASTMultiSelectHash:+ if value == nil {+ return nil, nil+ }+ collected := make(map[string]interface{})+ for _, child := range node.children {+ current, err := intr.Execute(child, value)+ if err != nil {+ return nil, err+ }+ key := child.value.(string)+ collected[key] = current+ }+ return collected, nil+ case ASTMultiSelectList:+ if value == nil {+ return nil, nil+ }+ collected := []interface{}{}+ for _, child := range node.children {+ current, err := intr.Execute(child, value)+ if err != nil {+ return nil, err+ }+ collected = append(collected, current)+ }+ return collected, nil+ case ASTOrExpression:+ matched, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ if isFalse(matched) {+ matched, err = intr.Execute(node.children[1], value)+ if err != nil {+ return nil, err+ }+ }+ return matched, nil+ case ASTAndExpression:+ matched, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ if isFalse(matched) {+ return matched, nil+ }+ return intr.Execute(node.children[1], value)+ case ASTNotExpression:+ matched, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ if isFalse(matched) {+ return true, nil+ }+ return false, nil+ case ASTPipe:+ result := value+ var err error+ for _, child := range node.children {+ result, err = intr.Execute(child, result)+ if err != nil {+ return nil, err+ }+ }+ return result, nil+ case ASTProjection:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ sliceType, ok := left.([]interface{})+ if !ok {+ if isSliceType(left) {+ return intr.projectWithReflection(node, left)+ }+ return nil, nil+ }+ collected := []interface{}{}+ var current interface{}+ for _, element := range sliceType {+ current, err = intr.Execute(node.children[1], element)+ if err != nil {+ return nil, err+ }+ if current != nil {+ collected = append(collected, current)+ }+ }+ return collected, nil+ case ASTSubexpression, ASTIndexExpression:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, err+ }+ return intr.Execute(node.children[1], left)+ case ASTSlice:+ sliceType, ok := value.([]interface{})+ if !ok {+ if isSliceType(value) {+ return intr.sliceWithReflection(node, value)+ }+ return nil, nil+ }+ parts := node.value.([]*int)+ sliceParams := make([]sliceParam, 3)+ for i, part := range parts {+ if part != nil {+ sliceParams[i].Specified = true+ sliceParams[i].N = *part+ }+ }+ return slice(sliceType, sliceParams)+ case ASTValueProjection:+ left, err := intr.Execute(node.children[0], value)+ if err != nil {+ return nil, nil+ }+ mapType, ok := left.(map[string]interface{})+ if !ok {+ return nil, nil+ }+ values := make([]interface{}, len(mapType))+ for _, value := range mapType {+ values = append(values, value)+ }+ collected := []interface{}{}+ for _, element := range values {+ current, err := intr.Execute(node.children[1], element)+ if err != nil {+ return nil, err+ }+ if current != nil {+ collected = append(collected, current)+ }+ }+ return collected, nil+ }+ return nil, errors.New("Unknown AST node: " + node.nodeType.String())+}++func (intr *treeInterpreter) fieldFromStruct(key string, value interface{}) (interface{}, error) {+ rv := reflect.ValueOf(value)+ first, n := utf8.DecodeRuneInString(key)+ fieldName := string(unicode.ToUpper(first)) + key[n:]+ if rv.Kind() == reflect.Struct {+ v := rv.FieldByName(fieldName)+ if !v.IsValid() {+ return nil, nil+ }+ return v.Interface(), nil+ } else if rv.Kind() == reflect.Ptr {+ // Handle multiple levels of indirection?+ if rv.IsNil() {+ return nil, nil+ }+ rv = rv.Elem()+ v := rv.FieldByName(fieldName)+ if !v.IsValid() {+ return nil, nil+ }+ return v.Interface(), nil+ }+ return nil, nil+}++func (intr *treeInterpreter) flattenWithReflection(value interface{}) (interface{}, error) {+ v := reflect.ValueOf(value)+ flattened := []interface{}{}+ for i := 0; i < v.Len(); i++ {+ element := v.Index(i).Interface()+ if reflect.TypeOf(element).Kind() == reflect.Slice {+ // Then insert the contents of the element+ // slice into the flattened slice,+ // i.e flattened = append(flattened, mySlice...)+ elementV := reflect.ValueOf(element)+ for j := 0; j < elementV.Len(); j++ {+ flattened = append(+ flattened, elementV.Index(j).Interface())+ }+ } else {+ flattened = append(flattened, element)+ }+ }+ return flattened, nil+}++func (intr *treeInterpreter) sliceWithReflection(node ASTNode, value interface{}) (interface{}, error) {+ v := reflect.ValueOf(value)+ parts := node.value.([]*int)+ sliceParams := make([]sliceParam, 3)+ for i, part := range parts {+ if part != nil {+ sliceParams[i].Specified = true+ sliceParams[i].N = *part+ }+ }+ final := []interface{}{}+ for i := 0; i < v.Len(); i++ {+ element := v.Index(i).Interface()+ final = append(final, element)+ }+ return slice(final, sliceParams)+}++func (intr *treeInterpreter) filterProjectionWithReflection(node ASTNode, value interface{}) (interface{}, error) {+ compareNode := node.children[2]+ collected := []interface{}{}+ v := reflect.ValueOf(value)+ for i := 0; i < v.Len(); i++ {+ element := v.Index(i).Interface()+ result, err := intr.Execute(compareNode, element)+ if err != nil {+ return nil, err+ }+ if !isFalse(result) {+ current, err := intr.Execute(node.children[1], element)+ if err != nil {+ return nil, err+ }+ if current != nil {+ collected = append(collected, current)+ }+ }+ }+ return collected, nil+}++func (intr *treeInterpreter) projectWithReflection(node ASTNode, value interface{}) (interface{}, error) {+ collected := []interface{}{}+ v := reflect.ValueOf(value)+ for i := 0; i < v.Len(); i++ {+ element := v.Index(i).Interface()+ result, err := intr.Execute(node.children[1], element)+ if err != nil {+ return nil, err+ }+ if result != nil {+ collected = append(collected, result)+ }+ }+ return collected, nil+}diff --git a/vendor/github.com/jmespath/go-jmespath/lexer.go b/vendor/github.com/jmespath/go-jmespath/lexer.gonew file mode 100644index 000000000..817900c8f--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/lexer.go@@ -0,0 +1,420 @@+package jmespath++import (+ "bytes"+ "encoding/json"+ "fmt"+ "strconv"+ "strings"+ "unicode/utf8"+)++type token struct {+ tokenType tokType+ value string+ position int+ length int+}++type tokType int++const eof = -1++// Lexer contains information about the expression being tokenized.+type Lexer struct {+ expression string // The expression provided by the user.+ currentPos int // The current position in the string.+ lastWidth int // The width of the current rune. This+ buf bytes.Buffer // Internal buffer used for building up values.+}++// SyntaxError is the main error used whenever a lexing or parsing error occurs.+type SyntaxError struct {+ msg string // Error message displayed to user+ Expression string // Expression that generated a SyntaxError+ Offset int // The location in the string where the error occurred+}++func (e SyntaxError) Error() string {+ // In the future, it would be good to underline the specific+ // location where the error occurred.+ return "SyntaxError: " + e.msg+}++// HighlightLocation will show where the syntax error occurred.+// It will place a "^" character on a line below the expression+// at the point where the syntax error occurred.+func (e SyntaxError) HighlightLocation() string {+ return e.Expression + "\n" + strings.Repeat(" ", e.Offset) + "^"+}++//go:generate stringer -type=tokType+const (+ tUnknown tokType = iota+ tStar+ tDot+ tFilter+ tFlatten+ tLparen+ tRparen+ tLbracket+ tRbracket+ tLbrace+ tRbrace+ tOr+ tPipe+ tNumber+ tUnquotedIdentifier+ tQuotedIdentifier+ tComma+ tColon+ tLT+ tLTE+ tGT+ tGTE+ tEQ+ tNE+ tJSONLiteral+ tStringLiteral+ tCurrent+ tExpref+ tAnd+ tNot+ tEOF+)++var basicTokens = map[rune]tokType{+ '.': tDot,+ '*': tStar,+ ',': tComma,+ ':': tColon,+ '{': tLbrace,+ '}': tRbrace,+ ']': tRbracket, // tLbracket not included because it could be "[]"+ '(': tLparen,+ ')': tRparen,+ '@': tCurrent,+}++// Bit mask for [a-zA-Z_] shifted down 64 bits to fit in a single uint64.+// When using this bitmask just be sure to shift the rune down 64 bits+// before checking against identifierStartBits.+const identifierStartBits uint64 = 576460745995190270++// Bit mask for [a-zA-Z0-9], 128 bits -> 2 uint64s.+var identifierTrailingBits = [2]uint64{287948901175001088, 576460745995190270}++var whiteSpace = map[rune]bool{+ ' ': true, '\t': true, '\n': true, '\r': true,+}++func (t token) String() string {+ return fmt.Sprintf("Token{%+v, %s, %d, %d}",+ t.tokenType, t.value, t.position, t.length)+}++// NewLexer creates a new JMESPath lexer.+func NewLexer() *Lexer {+ lexer := Lexer{}+ return &lexer+}++func (lexer *Lexer) next() rune {+ if lexer.currentPos >= len(lexer.expression) {+ lexer.lastWidth = 0+ return eof+ }+ r, w := utf8.DecodeRuneInString(lexer.expression[lexer.currentPos:])+ lexer.lastWidth = w+ lexer.currentPos += w+ return r+}++func (lexer *Lexer) back() {+ lexer.currentPos -= lexer.lastWidth+}++func (lexer *Lexer) peek() rune {+ t := lexer.next()+ lexer.back()+ return t+}++// tokenize takes an expression and returns corresponding tokens.+func (lexer *Lexer) tokenize(expression string) ([]token, error) {+ var tokens []token+ lexer.expression = expression+ lexer.currentPos = 0+ lexer.lastWidth = 0+loop:+ for {+ r := lexer.next()+ if identifierStartBits&(1<<(uint64(r)-64)) > 0 {+ t := lexer.consumeUnquotedIdentifier()+ tokens = append(tokens, t)+ } else if val, ok := basicTokens[r]; ok {+ // Basic single char token.+ t := token{+ tokenType: val,+ value: string(r),+ position: lexer.currentPos - lexer.lastWidth,+ length: 1,+ }+ tokens = append(tokens, t)+ } else if r == '-' || (r >= '0' && r <= '9') {+ t := lexer.consumeNumber()+ tokens = append(tokens, t)+ } else if r == '[' {+ t := lexer.consumeLBracket()+ tokens = append(tokens, t)+ } else if r == '"' {+ t, err := lexer.consumeQuotedIdentifier()+ if err != nil {+ return tokens, err+ }+ tokens = append(tokens, t)+ } else if r == '\'' {+ t, err := lexer.consumeRawStringLiteral()+ if err != nil {+ return tokens, err+ }+ tokens = append(tokens, t)+ } else if r == '`' {+ t, err := lexer.consumeLiteral()+ if err != nil {+ return tokens, err+ }+ tokens = append(tokens, t)+ } else if r == '|' {+ t := lexer.matchOrElse(r, '|', tOr, tPipe)+ tokens = append(tokens, t)+ } else if r == '<' {+ t := lexer.matchOrElse(r, '=', tLTE, tLT)+ tokens = append(tokens, t)+ } else if r == '>' {+ t := lexer.matchOrElse(r, '=', tGTE, tGT)+ tokens = append(tokens, t)+ } else if r == '!' {+ t := lexer.matchOrElse(r, '=', tNE, tNot)+ tokens = append(tokens, t)+ } else if r == '=' {+ t := lexer.matchOrElse(r, '=', tEQ, tUnknown)+ tokens = append(tokens, t)+ } else if r == '&' {+ t := lexer.matchOrElse(r, '&', tAnd, tExpref)+ tokens = append(tokens, t)+ } else if r == eof {+ break loop+ } else if _, ok := whiteSpace[r]; ok {+ // Ignore whitespace+ } else {+ return tokens, lexer.syntaxError(fmt.Sprintf("Unknown char: %s", strconv.QuoteRuneToASCII(r)))+ }+ }+ tokens = append(tokens, token{tEOF, "", len(lexer.expression), 0})+ return tokens, nil+}++// Consume characters until the ending rune "r" is reached.+// If the end of the expression is reached before seeing the+// terminating rune "r", then an error is returned.+// If no error occurs then the matching substring is returned.+// The returned string will not include the ending rune.+func (lexer *Lexer) consumeUntil(end rune) (string, error) {+ start := lexer.currentPos+ current := lexer.next()+ for current != end && current != eof {+ if current == '\\' && lexer.peek() != eof {+ lexer.next()+ }+ current = lexer.next()+ }+ if lexer.lastWidth == 0 {+ // Then we hit an EOF so we never reached the closing+ // delimiter.+ return "", SyntaxError{+ msg: "Unclosed delimiter: " + string(end),+ Expression: lexer.expression,+ Offset: len(lexer.expression),+ }+ }+ return lexer.expression[start : lexer.currentPos-lexer.lastWidth], nil+}++func (lexer *Lexer) consumeLiteral() (token, error) {+ start := lexer.currentPos+ value, err := lexer.consumeUntil('`')+ if err != nil {+ return token{}, err+ }+ value = strings.Replace(value, "\\`", "`", -1)+ return token{+ tokenType: tJSONLiteral,+ value: value,+ position: start,+ length: len(value),+ }, nil+}++func (lexer *Lexer) consumeRawStringLiteral() (token, error) {+ start := lexer.currentPos+ currentIndex := start+ current := lexer.next()+ for current != '\'' && lexer.peek() != eof {+ if current == '\\' && lexer.peek() == '\'' {+ chunk := lexer.expression[currentIndex : lexer.currentPos-1]+ lexer.buf.WriteString(chunk)+ lexer.buf.WriteString("'")+ lexer.next()+ currentIndex = lexer.currentPos+ }+ current = lexer.next()+ }+ if lexer.lastWidth == 0 {+ // Then we hit an EOF so we never reached the closing+ // delimiter.+ return token{}, SyntaxError{+ msg: "Unclosed delimiter: '",+ Expression: lexer.expression,+ Offset: len(lexer.expression),+ }+ }+ if currentIndex < lexer.currentPos {+ lexer.buf.WriteString(lexer.expression[currentIndex : lexer.currentPos-1])+ }+ value := lexer.buf.String()+ // Reset the buffer so it can reused again.+ lexer.buf.Reset()+ return token{+ tokenType: tStringLiteral,+ value: value,+ position: start,+ length: len(value),+ }, nil+}++func (lexer *Lexer) syntaxError(msg string) SyntaxError {+ return SyntaxError{+ msg: msg,+ Expression: lexer.expression,+ Offset: lexer.currentPos - 1,+ }+}++// Checks for a two char token, otherwise matches a single character+// token. This is used whenever a two char token overlaps a single+// char token, e.g. "||" -> tPipe, "|" -> tOr.+func (lexer *Lexer) matchOrElse(first rune, second rune, matchedType tokType, singleCharType tokType) token {+ start := lexer.currentPos - lexer.lastWidth+ nextRune := lexer.next()+ var t token+ if nextRune == second {+ t = token{+ tokenType: matchedType,+ value: string(first) + string(second),+ position: start,+ length: 2,+ }+ } else {+ lexer.back()+ t = token{+ tokenType: singleCharType,+ value: string(first),+ position: start,+ length: 1,+ }+ }+ return t+}++func (lexer *Lexer) consumeLBracket() token {+ // There's three options here:+ // 1. A filter expression "[?"+ // 2. A flatten operator "[]"+ // 3. A bare rbracket "["+ start := lexer.currentPos - lexer.lastWidth+ nextRune := lexer.next()+ var t token+ if nextRune == '?' {+ t = token{+ tokenType: tFilter,+ value: "[?",+ position: start,+ length: 2,+ }+ } else if nextRune == ']' {+ t = token{+ tokenType: tFlatten,+ value: "[]",+ position: start,+ length: 2,+ }+ } else {+ t = token{+ tokenType: tLbracket,+ value: "[",+ position: start,+ length: 1,+ }+ lexer.back()+ }+ return t+}++func (lexer *Lexer) consumeQuotedIdentifier() (token, error) {+ start := lexer.currentPos+ value, err := lexer.consumeUntil('"')+ if err != nil {+ return token{}, err+ }+ var decoded string+ asJSON := []byte("\"" + value + "\"")+ if err := json.Unmarshal([]byte(asJSON), &decoded); err != nil {+ return token{}, err+ }+ return token{+ tokenType: tQuotedIdentifier,+ value: decoded,+ position: start - 1,+ length: len(decoded),+ }, nil+}++func (lexer *Lexer) consumeUnquotedIdentifier() token {+ // Consume runes until we reach the end of an unquoted+ // identifier.+ start := lexer.currentPos - lexer.lastWidth+ for {+ r := lexer.next()+ if r < 0 || r > 128 || identifierTrailingBits[uint64(r)/64]&(1<<(uint64(r)%64)) == 0 {+ lexer.back()+ break+ }+ }+ value := lexer.expression[start:lexer.currentPos]+ return token{+ tokenType: tUnquotedIdentifier,+ value: value,+ position: start,+ length: lexer.currentPos - start,+ }+}++func (lexer *Lexer) consumeNumber() token {+ // Consume runes until we reach something that's not a number.+ start := lexer.currentPos - lexer.lastWidth+ for {+ r := lexer.next()+ if r < '0' || r > '9' {+ lexer.back()+ break+ }+ }+ value := lexer.expression[start:lexer.currentPos]+ return token{+ tokenType: tNumber,+ value: value,+ position: start,+ length: lexer.currentPos - start,+ }+}diff --git a/vendor/github.com/jmespath/go-jmespath/parser.go b/vendor/github.com/jmespath/go-jmespath/parser.gonew file mode 100644index 000000000..1240a1755--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/parser.go@@ -0,0 +1,603 @@+package jmespath++import (+ "encoding/json"+ "fmt"+ "strconv"+ "strings"+)++type astNodeType int++//go:generate stringer -type astNodeType+const (+ ASTEmpty astNodeType = iota+ ASTComparator+ ASTCurrentNode+ ASTExpRef+ ASTFunctionExpression+ ASTField+ ASTFilterProjection+ ASTFlatten+ ASTIdentity+ ASTIndex+ ASTIndexExpression+ ASTKeyValPair+ ASTLiteral+ ASTMultiSelectHash+ ASTMultiSelectList+ ASTOrExpression+ ASTAndExpression+ ASTNotExpression+ ASTPipe+ ASTProjection+ ASTSubexpression+ ASTSlice+ ASTValueProjection+)++// ASTNode represents the abstract syntax tree of a JMESPath expression.+type ASTNode struct {+ nodeType astNodeType+ value interface{}+ children []ASTNode+}++func (node ASTNode) String() string {+ return node.PrettyPrint(0)+}++// PrettyPrint will pretty print the parsed AST.+// The AST is an implementation detail and this pretty print+// function is provided as a convenience method to help with+// debugging. You should not rely on its output as the internal+// structure of the AST may change at any time.+func (node ASTNode) PrettyPrint(indent int) string {+ spaces := strings.Repeat(" ", indent)+ output := fmt.Sprintf("%s%s {\n", spaces, node.nodeType)+ nextIndent := indent + 2+ if node.value != nil {+ if converted, ok := node.value.(fmt.Stringer); ok {+ // Account for things like comparator nodes+ // that are enums with a String() method.+ output += fmt.Sprintf("%svalue: %s\n", strings.Repeat(" ", nextIndent), converted.String())+ } else {+ output += fmt.Sprintf("%svalue: %#v\n", strings.Repeat(" ", nextIndent), node.value)+ }+ }+ lastIndex := len(node.children)+ if lastIndex > 0 {+ output += fmt.Sprintf("%schildren: {\n", strings.Repeat(" ", nextIndent))+ childIndent := nextIndent + 2+ for _, elem := range node.children {+ output += elem.PrettyPrint(childIndent)+ }+ }+ output += fmt.Sprintf("%s}\n", spaces)+ return output+}++var bindingPowers = map[tokType]int{+ tEOF: 0,+ tUnquotedIdentifier: 0,+ tQuotedIdentifier: 0,+ tRbracket: 0,+ tRparen: 0,+ tComma: 0,+ tRbrace: 0,+ tNumber: 0,+ tCurrent: 0,+ tExpref: 0,+ tColon: 0,+ tPipe: 1,+ tOr: 2,+ tAnd: 3,+ tEQ: 5,+ tLT: 5,+ tLTE: 5,+ tGT: 5,+ tGTE: 5,+ tNE: 5,+ tFlatten: 9,+ tStar: 20,+ tFilter: 21,+ tDot: 40,+ tNot: 45,+ tLbrace: 50,+ tLbracket: 55,+ tLparen: 60,+}++// Parser holds state about the current expression being parsed.+type Parser struct {+ expression string+ tokens []token+ index int+}++// NewParser creates a new JMESPath parser.+func NewParser() *Parser {+ p := Parser{}+ return &p+}++// Parse will compile a JMESPath expression.+func (p *Parser) Parse(expression string) (ASTNode, error) {+ lexer := NewLexer()+ p.expression = expression+ p.index = 0+ tokens, err := lexer.tokenize(expression)+ if err != nil {+ return ASTNode{}, err+ }+ p.tokens = tokens+ parsed, err := p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ if p.current() != tEOF {+ return ASTNode{}, p.syntaxError(fmt.Sprintf(+ "Unexpected token at the end of the expresssion: %s", p.current()))+ }+ return parsed, nil+}++func (p *Parser) parseExpression(bindingPower int) (ASTNode, error) {+ var err error+ leftToken := p.lookaheadToken(0)+ p.advance()+ leftNode, err := p.nud(leftToken)+ if err != nil {+ return ASTNode{}, err+ }+ currentToken := p.current()+ for bindingPower < bindingPowers[currentToken] {+ p.advance()+ leftNode, err = p.led(currentToken, leftNode)+ if err != nil {+ return ASTNode{}, err+ }+ currentToken = p.current()+ }+ return leftNode, nil+}++func (p *Parser) parseIndexExpression() (ASTNode, error) {+ if p.lookahead(0) == tColon || p.lookahead(1) == tColon {+ return p.parseSliceExpression()+ }+ indexStr := p.lookaheadToken(0).value+ parsedInt, err := strconv.Atoi(indexStr)+ if err != nil {+ return ASTNode{}, err+ }+ indexNode := ASTNode{nodeType: ASTIndex, value: parsedInt}+ p.advance()+ if err := p.match(tRbracket); err != nil {+ return ASTNode{}, err+ }+ return indexNode, nil+}++func (p *Parser) parseSliceExpression() (ASTNode, error) {+ parts := []*int{nil, nil, nil}+ index := 0+ current := p.current()+ for current != tRbracket && index < 3 {+ if current == tColon {+ index+++ p.advance()+ } else if current == tNumber {+ parsedInt, err := strconv.Atoi(p.lookaheadToken(0).value)+ if err != nil {+ return ASTNode{}, err+ }+ parts[index] = &parsedInt+ p.advance()+ } else {+ return ASTNode{}, p.syntaxError(+ "Expected tColon or tNumber" + ", received: " + p.current().String())+ }+ current = p.current()+ }+ if err := p.match(tRbracket); err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTSlice,+ value: parts,+ }, nil+}++func (p *Parser) match(tokenType tokType) error {+ if p.current() == tokenType {+ p.advance()+ return nil+ }+ return p.syntaxError("Expected " + tokenType.String() + ", received: " + p.current().String())+}++func (p *Parser) led(tokenType tokType, node ASTNode) (ASTNode, error) {+ switch tokenType {+ case tDot:+ if p.current() != tStar {+ right, err := p.parseDotRHS(bindingPowers[tDot])+ return ASTNode{+ nodeType: ASTSubexpression,+ children: []ASTNode{node, right},+ }, err+ }+ p.advance()+ right, err := p.parseProjectionRHS(bindingPowers[tDot])+ return ASTNode{+ nodeType: ASTValueProjection,+ children: []ASTNode{node, right},+ }, err+ case tPipe:+ right, err := p.parseExpression(bindingPowers[tPipe])+ return ASTNode{nodeType: ASTPipe, children: []ASTNode{node, right}}, err+ case tOr:+ right, err := p.parseExpression(bindingPowers[tOr])+ return ASTNode{nodeType: ASTOrExpression, children: []ASTNode{node, right}}, err+ case tAnd:+ right, err := p.parseExpression(bindingPowers[tAnd])+ return ASTNode{nodeType: ASTAndExpression, children: []ASTNode{node, right}}, err+ case tLparen:+ name := node.value+ var args []ASTNode+ for p.current() != tRparen {+ expression, err := p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ if p.current() == tComma {+ if err := p.match(tComma); err != nil {+ return ASTNode{}, err+ }+ }+ args = append(args, expression)+ }+ if err := p.match(tRparen); err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTFunctionExpression,+ value: name,+ children: args,+ }, nil+ case tFilter:+ return p.parseFilter(node)+ case tFlatten:+ left := ASTNode{nodeType: ASTFlatten, children: []ASTNode{node}}+ right, err := p.parseProjectionRHS(bindingPowers[tFlatten])+ return ASTNode{+ nodeType: ASTProjection,+ children: []ASTNode{left, right},+ }, err+ case tEQ, tNE, tGT, tGTE, tLT, tLTE:+ right, err := p.parseExpression(bindingPowers[tokenType])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTComparator,+ value: tokenType,+ children: []ASTNode{node, right},+ }, nil+ case tLbracket:+ tokenType := p.current()+ var right ASTNode+ var err error+ if tokenType == tNumber || tokenType == tColon {+ right, err = p.parseIndexExpression()+ if err != nil {+ return ASTNode{}, err+ }+ return p.projectIfSlice(node, right)+ }+ // Otherwise this is a projection.+ if err := p.match(tStar); err != nil {+ return ASTNode{}, err+ }+ if err := p.match(tRbracket); err != nil {+ return ASTNode{}, err+ }+ right, err = p.parseProjectionRHS(bindingPowers[tStar])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTProjection,+ children: []ASTNode{node, right},+ }, nil+ }+ return ASTNode{}, p.syntaxError("Unexpected token: " + tokenType.String())+}++func (p *Parser) nud(token token) (ASTNode, error) {+ switch token.tokenType {+ case tJSONLiteral:+ var parsed interface{}+ err := json.Unmarshal([]byte(token.value), &parsed)+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{nodeType: ASTLiteral, value: parsed}, nil+ case tStringLiteral:+ return ASTNode{nodeType: ASTLiteral, value: token.value}, nil+ case tUnquotedIdentifier:+ return ASTNode{+ nodeType: ASTField,+ value: token.value,+ }, nil+ case tQuotedIdentifier:+ node := ASTNode{nodeType: ASTField, value: token.value}+ if p.current() == tLparen {+ return ASTNode{}, p.syntaxErrorToken("Can't have quoted identifier as function name.", token)+ }+ return node, nil+ case tStar:+ left := ASTNode{nodeType: ASTIdentity}+ var right ASTNode+ var err error+ if p.current() == tRbracket {+ right = ASTNode{nodeType: ASTIdentity}+ } else {+ right, err = p.parseProjectionRHS(bindingPowers[tStar])+ }+ return ASTNode{nodeType: ASTValueProjection, children: []ASTNode{left, right}}, err+ case tFilter:+ return p.parseFilter(ASTNode{nodeType: ASTIdentity})+ case tLbrace:+ return p.parseMultiSelectHash()+ case tFlatten:+ left := ASTNode{+ nodeType: ASTFlatten,+ children: []ASTNode{{nodeType: ASTIdentity}},+ }+ right, err := p.parseProjectionRHS(bindingPowers[tFlatten])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{nodeType: ASTProjection, children: []ASTNode{left, right}}, nil+ case tLbracket:+ tokenType := p.current()+ //var right ASTNode+ if tokenType == tNumber || tokenType == tColon {+ right, err := p.parseIndexExpression()+ if err != nil {+ return ASTNode{}, nil+ }+ return p.projectIfSlice(ASTNode{nodeType: ASTIdentity}, right)+ } else if tokenType == tStar && p.lookahead(1) == tRbracket {+ p.advance()+ p.advance()+ right, err := p.parseProjectionRHS(bindingPowers[tStar])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTProjection,+ children: []ASTNode{{nodeType: ASTIdentity}, right},+ }, nil+ } else {+ return p.parseMultiSelectList()+ }+ case tCurrent:+ return ASTNode{nodeType: ASTCurrentNode}, nil+ case tExpref:+ expression, err := p.parseExpression(bindingPowers[tExpref])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{nodeType: ASTExpRef, children: []ASTNode{expression}}, nil+ case tNot:+ expression, err := p.parseExpression(bindingPowers[tNot])+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{nodeType: ASTNotExpression, children: []ASTNode{expression}}, nil+ case tLparen:+ expression, err := p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ if err := p.match(tRparen); err != nil {+ return ASTNode{}, err+ }+ return expression, nil+ case tEOF:+ return ASTNode{}, p.syntaxErrorToken("Incomplete expression", token)+ }++ return ASTNode{}, p.syntaxErrorToken("Invalid token: "+token.tokenType.String(), token)+}++func (p *Parser) parseMultiSelectList() (ASTNode, error) {+ var expressions []ASTNode+ for {+ expression, err := p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ expressions = append(expressions, expression)+ if p.current() == tRbracket {+ break+ }+ err = p.match(tComma)+ if err != nil {+ return ASTNode{}, err+ }+ }+ err := p.match(tRbracket)+ if err != nil {+ return ASTNode{}, err+ }+ return ASTNode{+ nodeType: ASTMultiSelectList,+ children: expressions,+ }, nil+}++func (p *Parser) parseMultiSelectHash() (ASTNode, error) {+ var children []ASTNode+ for {+ keyToken := p.lookaheadToken(0)+ if err := p.match(tUnquotedIdentifier); err != nil {+ if err := p.match(tQuotedIdentifier); err != nil {+ return ASTNode{}, p.syntaxError("Expected tQuotedIdentifier or tUnquotedIdentifier")+ }+ }+ keyName := keyToken.value+ err := p.match(tColon)+ if err != nil {+ return ASTNode{}, err+ }+ value, err := p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ node := ASTNode{+ nodeType: ASTKeyValPair,+ value: keyName,+ children: []ASTNode{value},+ }+ children = append(children, node)+ if p.current() == tComma {+ err := p.match(tComma)+ if err != nil {+ return ASTNode{}, nil+ }+ } else if p.current() == tRbrace {+ err := p.match(tRbrace)+ if err != nil {+ return ASTNode{}, nil+ }+ break+ }+ }+ return ASTNode{+ nodeType: ASTMultiSelectHash,+ children: children,+ }, nil+}++func (p *Parser) projectIfSlice(left ASTNode, right ASTNode) (ASTNode, error) {+ indexExpr := ASTNode{+ nodeType: ASTIndexExpression,+ children: []ASTNode{left, right},+ }+ if right.nodeType == ASTSlice {+ right, err := p.parseProjectionRHS(bindingPowers[tStar])+ return ASTNode{+ nodeType: ASTProjection,+ children: []ASTNode{indexExpr, right},+ }, err+ }+ return indexExpr, nil+}+func (p *Parser) parseFilter(node ASTNode) (ASTNode, error) {+ var right, condition ASTNode+ var err error+ condition, err = p.parseExpression(0)+ if err != nil {+ return ASTNode{}, err+ }+ if err := p.match(tRbracket); err != nil {+ return ASTNode{}, err+ }+ if p.current() == tFlatten {+ right = ASTNode{nodeType: ASTIdentity}+ } else {+ right, err = p.parseProjectionRHS(bindingPowers[tFilter])+ if err != nil {+ return ASTNode{}, err+ }+ }++ return ASTNode{+ nodeType: ASTFilterProjection,+ children: []ASTNode{node, right, condition},+ }, nil+}++func (p *Parser) parseDotRHS(bindingPower int) (ASTNode, error) {+ lookahead := p.current()+ if tokensOneOf([]tokType{tQuotedIdentifier, tUnquotedIdentifier, tStar}, lookahead) {+ return p.parseExpression(bindingPower)+ } else if lookahead == tLbracket {+ if err := p.match(tLbracket); err != nil {+ return ASTNode{}, err+ }+ return p.parseMultiSelectList()+ } else if lookahead == tLbrace {+ if err := p.match(tLbrace); err != nil {+ return ASTNode{}, err+ }+ return p.parseMultiSelectHash()+ }+ return ASTNode{}, p.syntaxError("Expected identifier, lbracket, or lbrace")+}++func (p *Parser) parseProjectionRHS(bindingPower int) (ASTNode, error) {+ current := p.current()+ if bindingPowers[current] < 10 {+ return ASTNode{nodeType: ASTIdentity}, nil+ } else if current == tLbracket {+ return p.parseExpression(bindingPower)+ } else if current == tFilter {+ return p.parseExpression(bindingPower)+ } else if current == tDot {+ err := p.match(tDot)+ if err != nil {+ return ASTNode{}, err+ }+ return p.parseDotRHS(bindingPower)+ } else {+ return ASTNode{}, p.syntaxError("Error")+ }+}++func (p *Parser) lookahead(number int) tokType {+ return p.lookaheadToken(number).tokenType+}++func (p *Parser) current() tokType {+ return p.lookahead(0)+}++func (p *Parser) lookaheadToken(number int) token {+ return p.tokens[p.index+number]+}++func (p *Parser) advance() {+ p.index+++}++func tokensOneOf(elements []tokType, token tokType) bool {+ for _, elem := range elements {+ if elem == token {+ return true+ }+ }+ return false+}++func (p *Parser) syntaxError(msg string) SyntaxError {+ return SyntaxError{+ msg: msg,+ Expression: p.expression,+ Offset: p.lookaheadToken(0).position,+ }+}++// Create a SyntaxError based on the provided token.+// This differs from syntaxError() which creates a SyntaxError+// based on the current lookahead token.+func (p *Parser) syntaxErrorToken(msg string, t token) SyntaxError {+ return SyntaxError{+ msg: msg,+ Expression: p.expression,+ Offset: t.position,+ }+}diff --git a/vendor/github.com/jmespath/go-jmespath/toktype_string.go b/vendor/github.com/jmespath/go-jmespath/toktype_string.gonew file mode 100644index 000000000..dae79cbdf--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/toktype_string.go@@ -0,0 +1,16 @@+// generated by stringer -type=tokType; DO NOT EDIT++package jmespath++import "fmt"++const _tokType_name = "tUnknowntStartDottFiltertFlattentLparentRparentLbrackettRbrackettLbracetRbracetOrtPipetNumbertUnquotedIdentifiertQuotedIdentifiertCommatColontLTtLTEtGTtGTEtEQtNEtJSONLiteraltStringLiteraltCurrenttExpreftAndtNottEOF"++var _tokType_index = [...]uint8{0, 8, 13, 17, 24, 32, 39, 46, 55, 64, 71, 78, 81, 86, 93, 112, 129, 135, 141, 144, 148, 151, 155, 158, 161, 173, 187, 195, 202, 206, 210, 214}++func (i tokType) String() string {+ if i < 0 || i >= tokType(len(_tokType_index)-1) {+ return fmt.Sprintf("tokType(%d)", i)+ }+ return _tokType_name[_tokType_index[i]:_tokType_index[i+1]]+}diff --git a/vendor/github.com/jmespath/go-jmespath/util.go b/vendor/github.com/jmespath/go-jmespath/util.gonew file mode 100644index 000000000..ddc1b7d7d--- /dev/null+++ b/vendor/github.com/jmespath/go-jmespath/util.go@@ -0,0 +1,185 @@+package jmespath++import (+ "errors"+ "reflect"+)++// IsFalse determines if an object is false based on the JMESPath spec.+// JMESPath defines false values to be any of:+// - An empty string array, or hash.+// - The boolean value false.+// - nil+func isFalse(value interface{}) bool {+ switch v := value.(type) {+ case bool:+ return !v+ case []interface{}:+ return len(v) == 0+ case map[string]interface{}:+ return len(v) == 0+ case string:+ return len(v) == 0+ case nil:+ return true+ }+ // Try the reflection cases before returning false.+ rv := reflect.ValueOf(value)+ switch rv.Kind() {+ case reflect.Struct:+ // A struct type will never be false, even if+ // all of its values are the zero type.+ return false+ case reflect.Slice, reflect.Map:+ return rv.Len() == 0+ case reflect.Ptr:+ if rv.IsNil() {+ return true+ }+ // If it's a pointer type, we'll try to deref the pointer+ // and evaluate the pointer value for isFalse.+ element := rv.Elem()+ return isFalse(element.Interface())+ }+ return false+}++// ObjsEqual is a generic object equality check.+// It will take two arbitrary objects and recursively determine+// if they are equal.+func objsEqual(left interface{}, right interface{}) bool {+ return reflect.DeepEqual(left, right)+}++// SliceParam refers to a single part of a slice.+// A slice consists of a start, a stop, and a step, similar to+// python slices.+type sliceParam struct {+ N int+ Specified bool+}++// Slice supports [start:stop:step] style slicing that's supported in JMESPath.+func slice(slice []interface{}, parts []sliceParam) ([]interface{}, error) {+ computed, err := computeSliceParams(len(slice), parts)+ if err != nil {+ return nil, err+ }+ start, stop, step := computed[0], computed[1], computed[2]+ result := []interface{}{}+ if step > 0 {+ for i := start; i < stop; i += step {+ result = append(result, slice[i])+ }+ } else {+ for i := start; i > stop; i += step {+ result = append(result, slice[i])+ }+ }+ return result, nil+}++func computeSliceParams(length int, parts []sliceParam) ([]int, error) {+ var start, stop, step int+ if !parts[2].Specified {+ step = 1+ } else if parts[2].N == 0 {+ return nil, errors.New("Invalid slice, step cannot be 0")+ } else {+ step = parts[2].N+ }+ var stepValueNegative bool+ if step < 0 {+ stepValueNegative = true+ } else {+ stepValueNegative = false+ }++ if !parts[0].Specified {+ if stepValueNegative {+ start = length - 1+ } else {+ start = 0+ }+ } else {+ start = capSlice(length, parts[0].N, step)+ }++ if !parts[1].Specified {+ if stepValueNegative {+ stop = -1+ } else {+ stop = length+ }+ } else {+ stop = capSlice(length, parts[1].N, step)+ }+ return []int{start, stop, step}, nil+}++func capSlice(length int, actual int, step int) int {+ if actual < 0 {+ actual += length+ if actual < 0 {+ if step < 0 {+ actual = -1+ } else {+ actual = 0+ }+ }+ } else if actual >= length {+ if step < 0 {+ actual = length - 1+ } else {+ actual = length+ }+ }+ return actual+}++// ToArrayNum converts an empty interface type to a slice of float64.+// If any element in the array cannot be converted, then nil is returned+// along with a second value of false.+func toArrayNum(data interface{}) ([]float64, bool) {+ // Is there a better way to do this with reflect?+ if d, ok := data.([]interface{}); ok {+ result := make([]float64, len(d))+ for i, el := range d {+ item, ok := el.(float64)+ if !ok {+ return nil, false+ }+ result[i] = item+ }+ return result, true+ }+ return nil, false+}++// ToArrayStr converts an empty interface type to a slice of strings.+// If any element in the array cannot be converted, then nil is returned+// along with a second value of false. If the input data could be entirely+// converted, then the converted data, along with a second value of true,+// will be returned.+func toArrayStr(data interface{}) ([]string, bool) {+ // Is there a better way to do this with reflect?+ if d, ok := data.([]interface{}); ok {+ result := make([]string, len(d))+ for i, el := range d {+ item, ok := el.(string)+ if !ok {+ return nil, false+ }+ result[i] = item+ }+ return result, true+ }+ return nil, false+}++func isSliceType(v interface{}) bool {+ if v == nil {+ return false+ }+ return reflect.TypeOf(v).Kind() == reflect.Slice+}