Switch to using the dep tool and update all the dependencies

vendor/github.com/aws/aws-sdk-go/example/service/cloudfront/signCookies/README.md

@@ -0,0 +1,12 @@
+# Example
+
+This example shows how the CloudFront CookieSigner can be used to generate signed cookies to provided short term access to restricted resourced fronted by CloudFront.
+
+# Usage
+Makes a request for object using CloudFront cookie signing, and outputs the contents of the object to stdout.
+
+```sh
+go run -tags example signCookies.go -file <privkey file>  -id <keyId> -r <resource pattern> -g <object to get>
+```
+
+

vendor/github.com/aws/aws-sdk-go/example/service/cloudfront/signCookies/signCookies.go

@@ -0,0 +1,79 @@
+// +build example
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/aws/aws-sdk-go/service/cloudfront/sign"
+)
+
+// Makes a request for object using CloudFront cookie signing, and outputs
+// the contents of the object to stdout.
+//
+// Usage example:
+// signCookies -file <privkey file>  -id <keyId> -r <resource pattern> -g <object to get>
+func main() {
+	var keyFile string  // Private key PEM file
+	var keyID string    // Key pair ID of CloudFront key pair
+	var resource string // CloudFront resource pattern
+	var object string   // S3 object frontented by CloudFront
+
+	flag.StringVar(&keyFile, "file", "", "private key file")
+	flag.StringVar(&keyID, "id", "", "key pair id")
+	flag.StringVar(&resource, "r", "", "resource to request")
+	flag.StringVar(&object, "g", "", "object to get")
+	flag.Parse()
+
+	// Load the PEM file into memory so it can be used by the signer
+	privKey, err := sign.LoadPEMPrivKeyFile(keyFile)
+	if err != nil {
+		fmt.Println("failed to load key,", err)
+		return
+	}
+
+	// Create the new CookieSigner to get signed cookies for CloudFront
+	// resource requests
+	signer := sign.NewCookieSigner(keyID, privKey)
+
+	// Get the cookies for the resource. These will be used
+	// to make the requests with
+	cookies, err := signer.Sign(resource, time.Now().Add(1*time.Hour))
+	if err != nil {
+		fmt.Println("failed to sign cookies", err)
+		return
+	}
+
+	// Use the cookies in a http.Client to show how they allow the client
+	// to request resources from CloudFront.
+	req, err := http.NewRequest("GET", object, nil)
+	fmt.Println("Cookies:")
+	for _, c := range cookies {
+		fmt.Printf("%s=%s;\n", c.Name, c.Value)
+		req.AddCookie(c)
+	}
+
+	// Send and handle the response. For a successful response the object's
+	// content will be written to stdout. The same process could be applied
+	// to a http service written cookies to the response but using
+	// http.SetCookie(w, c,) on the ResponseWriter.
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		fmt.Println("failed to send request", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	b, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Println("failed to read requested body", err)
+		return
+	}
+
+	fmt.Println("Response:", resp.Status)
+	fmt.Println(string(b))
+}

vendor/github.com/aws/aws-sdk-go/example/service/dynamodb/scanItems/README.md

@@ -0,0 +1,47 @@
+# Example
+
+`scanItems` is an example how to use Amazon DynamoDB's Scan API operation with the SDK's `dynamodbattributes.UnmarshalListOfMaps` to unmarshal the Scan response's `Items` `[]map[string]*dynamodb.AttributeValue` field. This unmarshaler can be used with all `[]map[string]*dynamodb.AttributeValue` type fields.
+
+## Go Type
+
+The `Item` time will be used by the example to unmarshal the DynamoDB table's items to.
+
+```go
+type Item struct {
+	Key  int
+	Desc string
+	Data map[string]interface{}
+}
+```
+Use Go tags to define what the name is of the attribute in your DynamoDB table. See [AWS SDK for Go API Reference: Marshal](https://docs.aws.amazon.com/sdk-for-go/api/service/dynamodb/dynamodbattribute/#Marshal) for more information.
+
+In DynamoDB the structure of the item to be returned will be:
+```json
+{
+  "Data": {
+    "Value 1": "abc",
+    "Value 2": 1234567890
+  },
+  "Desc": "First ddb item",
+  "Key": 1
+}
+```
+
+## Usage
+
+`go run -tags example scanItems.go -table "<table_name>" -region "<optional_region>"`
+
+## Output
+
+```
+0: Key: 123, Desc: An item in the DynamoDB table
+	Num Data Values: 0
+1: Key: 2, Desc: Second ddb item
+	Num Data Values: 2
+	- "A Field": 123
+	- "Another Field": abc
+2: Key: 1, Desc: First ddb item
+	Num Data Values: 2
+	- "Value 1": abc
+	- "Value 2": 1234567890
+```

vendor/github.com/aws/aws-sdk-go/example/service/dynamodb/scanItems/scanItems.go

@@ -0,0 +1,98 @@
+// +build example
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
+)
+
+func exitWithError(err error) {
+	fmt.Fprintln(os.Stderr, err)
+	os.Exit(1)
+}
+
+func main() {
+	cfg := Config{}
+	if err := cfg.Load(); err != nil {
+		exitWithError(fmt.Errorf("failed to load config, %v", err))
+	}
+
+	// Create the config specifying the Region for the DynamoDB table.
+	// If Config.Region is not set the region must come from the shared
+	// config or AWS_REGION environment variable.
+	awscfg := &aws.Config{}
+	if len(cfg.Region) > 0 {
+		awscfg.WithRegion(cfg.Region)
+	}
+
+	// Create the session that the DynamoDB service will use.
+	sess := session.Must(session.NewSession(awscfg))
+
+	// Create the DynamoDB service client to make the query request with.
+	svc := dynamodb.New(sess)
+
+	// Build the query input parameters
+	params := &dynamodb.ScanInput{
+		TableName: aws.String(cfg.Table),
+	}
+	if cfg.Limit > 0 {
+		params.Limit = aws.Int64(cfg.Limit)
+	}
+
+	// Make the DynamoDB Query API call
+	result, err := svc.Scan(params)
+	if err != nil {
+		exitWithError(fmt.Errorf("failed to make Query API call, %v", err))
+	}
+
+	items := []Item{}
+
+	// Unmarshal the Items field in the result value to the Item Go type.
+	err = dynamodbattribute.UnmarshalListOfMaps(result.Items, &items)
+	if err != nil {
+		exitWithError(fmt.Errorf("failed to unmarshal Query result items, %v", err))
+	}
+
+	// Print out the items returned
+	for i, item := range items {
+		fmt.Printf("%d: Key: %d, Desc: %s\n", i, item.Key, item.Desc)
+		fmt.Printf("\tNum Data Values: %d\n", len(item.Data))
+		for k, v := range item.Data {
+			fmt.Printf("\t- %q: %v\n", k, v)
+		}
+	}
+}
+
+type Item struct {
+	Key  int
+	Desc string
+	Data map[string]interface{}
+}
+
+type Config struct {
+	Table  string // required
+	Region string // optional
+	Limit  int64  // optional
+
+}
+
+func (c *Config) Load() error {
+	flag.Int64Var(&c.Limit, "limit", 0, "Limit is the max items to be returned, 0 is no limit")
+	flag.StringVar(&c.Table, "table", "", "Table to Query on")
+	flag.StringVar(&c.Region, "region", "", "AWS Region the table is in")
+	flag.Parse()
+
+	if len(c.Table) == 0 {
+		flag.PrintDefaults()
+		return fmt.Errorf("table name is required.")
+	}
+
+	return nil
+}

vendor/github.com/aws/aws-sdk-go/example/service/dynamodb/unitTest/README.md

@@ -0,0 +1,52 @@
+# Example
+You can instantiate `*dynamodb.DynamoDB` and pass that as a parameter to all
+methods connecting to DynamoDB, or as `unitTest` demonstrates, create your own
+`type` and pass it along as a field.
+
+## Test-compatible DynamoDB field
+If you use `*dynamodb.DynamoDB` as a field, you will be unable to unit test it,
+as documented in #88. Cast it instead as `dynamodbiface.DynamoDBAPI`:
+
+```go
+type ItemGetter struct {
+		DynamoDB dynamodbiface.DynamoDBAPI
+}
+```
+
+## Querying actual DynamoDB
+You'll need an `*aws.Config` and `*session.Session` for these to work correctly:
+
+```go
+// Setup
+var getter = new(ItemGetter)
+var config *aws.Config = &aws.Config{Region: aws.String("us-west-2"),}
+var sess *session.Session = session.NewSession(config)
+var svc *dynamodb.DynamoDB = dynamodb.New()
+getter.DynamoDB = dynamodbiface.DynamoDBAPI(svc)
+// Finally
+getter.DynamoDB.GetItem(/* ... */)
+```
+
+## Querying in tests
+Construct a `fakeDynamoDB` and add the necessary methods for each of those
+structs (custom ones for `ItemGetter` and [whatever methods you're using for
+DynamoDB](https://github.com/aws/aws-sdk-go/blob/master/service/dynamodb/dynamodbiface/interface.go)),
+and you're good to go!
+
+```go
+type fakeDynamoDB struct {
+		dynamodbiface.DynamoDBAPI
+}
+var getter = new(ItemGetter)
+getter.DynamoDB = &fakeDynamoDB{}
+// And to run it (assuming you've mocked fakeDynamoDB.GetItem)
+getter.DynamoDB.GetItem(/* ... */)
+```
+
+## Output
+```
+$ go test -tags example -cover
+PASS
+coverage: 100.0% of statements
+ok		_/Users/shatil/workspace/aws-sdk-go/example/service/dynamodb/unitTest	0.008s
+```

vendor/github.com/aws/aws-sdk-go/example/service/dynamodb/unitTest/unitTest.go

@@ -0,0 +1,41 @@
+// +build example
+
+// Package unitTest demonstrates how to unit test, without needing to pass a
+// connector to every function, code that uses DynamoDB.
+package unitTest
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface"
+)
+
+// ItemGetter can be assigned a DynamoDB connector like:
+//	svc := dynamodb.DynamoDB(sess)
+//	getter.DynamoDB = dynamodbiface.DynamoDBAPI(svc)
+type ItemGetter struct {
+	DynamoDB dynamodbiface.DynamoDBAPI
+}
+
+// Get a value from a DynamoDB table containing entries like:
+// {"id": "my primary key", "value": "valuable value"}
+func (ig *ItemGetter) Get(id string) (value string) {
+	var input = &dynamodb.GetItemInput{
+		Key: map[string]*dynamodb.AttributeValue{
+			"id": {
+				S: aws.String(id),
+			},
+		},
+		TableName: aws.String("my_table"),
+		AttributesToGet: []*string{
+			aws.String("value"),
+		},
+	}
+	if output, err := ig.DynamoDB.GetItem(input); err == nil {
+		if _, ok := output.Item["value"]; ok {
+			dynamodbattribute.Unmarshal(output.Item["value"], &value)
+		}
+	}
+	return
+}

vendor/github.com/aws/aws-sdk-go/example/service/dynamodb/unitTest/unitTest_test.go

@@ -0,0 +1,59 @@
+// +build example
+
+// Unit tests for package unitTest.
+package unitTest
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface"
+)
+
+// A fakeDynamoDB instance. During testing, instatiate ItemGetter, then simply
+// assign an instance of fakeDynamoDB to it.
+type fakeDynamoDB struct {
+	dynamodbiface.DynamoDBAPI
+	payload map[string]string // Store expected return values
+	err     error
+}
+
+// Mock GetItem such that the output returned carries values identical to input.
+func (fd *fakeDynamoDB) GetItem(input *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) {
+	output := new(dynamodb.GetItemOutput)
+	output.Item = make(map[string]*dynamodb.AttributeValue)
+	for key, value := range fd.payload {
+		output.Item[key] = &dynamodb.AttributeValue{
+			S: aws.String(value),
+		}
+	}
+	return output, fd.err
+}
+
+func TestItemGetterGet(t *testing.T) {
+	expectedKey := "expected key"
+	expectedValue := "expected value"
+	getter := new(ItemGetter)
+	getter.DynamoDB = &fakeDynamoDB{
+		payload: map[string]string{"id": expectedKey, "value": expectedValue},
+	}
+	if actualValue := getter.Get(expectedKey); actualValue != expectedValue {
+		t.Errorf("Expected %q but got %q", expectedValue, actualValue)
+	}
+}
+
+// When DynamoDB.GetItem returns a non-nil error, expect an empty string.
+func TestItemGetterGetFail(t *testing.T) {
+	expectedKey := "expected key"
+	expectedValue := "expected value"
+	getter := new(ItemGetter)
+	getter.DynamoDB = &fakeDynamoDB{
+		payload: map[string]string{"id": expectedKey, "value": expectedValue},
+		err:     errors.New("any error"),
+	}
+	if actualValue := getter.Get(expectedKey); len(actualValue) > 0 {
+		t.Errorf("Expected %q but got %q", expectedValue, actualValue)
+	}
+}

vendor/github.com/aws/aws-sdk-go/example/service/ec2/filterInstances/README.md

@@ -0,0 +1,31 @@
+# Example
+
+This is an example using the AWS SDK for Go to list ec2 instances that match provided tag name filter.
+
+
+# Usage
+
+The example uses the bucket name provided, and lists all object keys in a bucket.
+
+```sh
+go run -tags example filter_ec2_by_tag.go <name_filter>
+```
+
+Output:
+```
+listing instances with tag vpn in: us-east-1
+[{
+  Instances: [{
+      AmiLaunchIndex: 0,
+      Architecture: "x86_64",
+      BlockDeviceMappings: [{
+          DeviceName: "/dev/xvda",
+          Ebs: {
+            AttachTime: 2016-07-06 18:04:53 +0000 UTC,
+            DeleteOnTermination: true,
+            Status: "attached",
+            VolumeId: "vol-xxxx"
+          }
+        }],
+      ...
+```

vendor/github.com/aws/aws-sdk-go/example/service/ec2/filterInstances/filter_ec2_by_tag.go

@@ -0,0 +1,43 @@
+// +build example
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+// This example will list instances with a filter
+//
+// Usage:
+// filter_ec2_by_tag <name_filter>
+func main() {
+	sess := session.Must(session.NewSession())
+
+	nameFilter := os.Args[1]
+	awsRegion := "us-east-1"
+	svc := ec2.New(sess, &aws.Config{Region: aws.String(awsRegion)})
+	fmt.Printf("listing instances with tag %v in: %v\n", nameFilter, awsRegion)
+	params := &ec2.DescribeInstancesInput{
+		Filters: []*ec2.Filter{
+			{
+				Name: aws.String("tag:Name"),
+				Values: []*string{
+					aws.String(strings.Join([]string{"*", nameFilter, "*"}, "")),
+				},
+			},
+		},
+	}
+	resp, err := svc.DescribeInstances(params)
+	if err != nil {
+		fmt.Println("there was an error listing instances in", awsRegion, err.Error())
+		log.Fatal(err.Error())
+	}
+	fmt.Printf("%+v\n", *resp)
+}

vendor/github.com/aws/aws-sdk-go/example/service/s3/concatObjects/README.md

@@ -0,0 +1,14 @@
+# Example
+
+This is an example using the AWS SDK for Go to concatenate two objects together.
+We use `UploadPartCopy` which uses an object for a part. Here in this example we have two parts, or in other words
+two objects that we want to concatenate together.
+
+
+# Usage
+
+The example uses the bucket name provided, two keys for each object, and lastly the output key.
+
+```sh
+AWS_REGION=<region> go run -tags example concatenateObjects.go <bucket> <key for object 1> <key for object 2> <key for output>
+```

vendor/github.com/aws/aws-sdk-go/example/service/s3/concatObjects/concatObjects.go

@@ -0,0 +1,104 @@
+// +build example
+
+package main
+
+import (
+	"log"
+	"net/url"
+	"os"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/s3"
+)
+
+type client struct {
+	s3Client *s3.S3
+	bucket   *string
+}
+
+// concatenate will contenate key1's object to key2's object under the key testKey
+func (c *client) concatenate(key1, key2, key3 string, uploadID *string) (*string, *string, error) {
+	// The first part to be uploaded which is represented as part number 1
+	foo, err := c.s3Client.UploadPartCopy(&s3.UploadPartCopyInput{
+		Bucket:     c.bucket,
+		CopySource: aws.String(url.QueryEscape(*c.bucket + "/" + key1)),
+		PartNumber: aws.Int64(1),
+		Key:        &key3,
+		UploadId:   uploadID,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// The second part that is going to be appended to the newly created testKey
+	// object.
+	bar, err := c.s3Client.UploadPartCopy(&s3.UploadPartCopyInput{
+		Bucket:     c.bucket,
+		CopySource: aws.String(url.QueryEscape(*c.bucket + "/" + key2)),
+		PartNumber: aws.Int64(2),
+		Key:        &key3,
+		UploadId:   uploadID,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+	// The ETags are needed to complete the process
+	return foo.CopyPartResult.ETag, bar.CopyPartResult.ETag, nil
+}
+
+func main() {
+	if len(os.Args) < 4 {
+		log.Println("USAGE ERROR: AWS_REGION=us-east-1 go run concatenateObjects.go <bucket> <key for object 1> <key for object 2> <key for output>")
+		return
+	}
+
+	bucket := os.Args[1]
+	key1 := os.Args[2]
+	key2 := os.Args[3]
+	key3 := os.Args[4]
+	sess := session.New(&aws.Config{})
+	svc := s3.New(sess)
+
+	c := client{svc, &bucket}
+
+	// We let the service know that we want to do a multipart upload
+	output, err := c.s3Client.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
+		Bucket: &bucket,
+		Key:    &key3,
+	})
+
+	if err != nil {
+		log.Println("ERROR:", err)
+		return
+	}
+
+	foo, bar, err := c.concatenate(key1, key2, key3, output.UploadId)
+	if err != nil {
+		log.Println("ERROR:", err)
+		return
+	}
+
+	// We finally complete the multipart upload.
+	_, err = c.s3Client.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
+		Bucket:   &bucket,
+		Key:      &key3,
+		UploadId: output.UploadId,
+		MultipartUpload: &s3.CompletedMultipartUpload{
+			Parts: []*s3.CompletedPart{
+				{
+					ETag:       foo,
+					PartNumber: aws.Int64(1),
+				},
+				{
+					ETag:       bar,
+					PartNumber: aws.Int64(2),
+				},
+			},
+		},
+	})
+	if err != nil {
+		log.Println("ERROR:", err)
+		return
+	}
+}

vendor/github.com/aws/aws-sdk-go/example/service/s3/listObjects/README.md

@@ -0,0 +1,27 @@
+# Example
+
+This is an example using the AWS SDK for Go to list objects' key in a S3 bucket.
+
+
+# Usage
+
+The example uses the bucket name provided, and lists all object keys in a bucket.
+
+```sh
+go run -tags example listObjects.go <bucket>
+```
+
+Output:
+```
+Page, 0
+Object: myKey
+Object: mykey.txt
+Object: resources/0001/item-01
+Object: resources/0001/item-02
+Object: resources/0001/item-03
+Object: resources/0002/item-01
+Object: resources/0002/item-02
+Object: resources/0002/item-03
+Object: resources/0002/item-04
+Object: resources/0002/item-05
+```

vendor/github.com/aws/aws-sdk-go/example/service/s3/listObjects/listObjects.go

@@ -0,0 +1,43 @@
+// +build example
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/s3"
+)
+
+// Lists all objects in a bucket using pagination
+//
+// Usage:
+// listObjects <bucket>
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("you must specify a bucket")
+		return
+	}
+
+	sess := session.Must(session.NewSession())
+
+	svc := s3.New(sess)
+
+	i := 0
+	err := svc.ListObjectsPages(&s3.ListObjectsInput{
+		Bucket: &os.Args[1],
+	}, func(p *s3.ListObjectsOutput, last bool) (shouldContinue bool) {
+		fmt.Println("Page,", i)
+		i++
+
+		for _, obj := range p.Contents {
+			fmt.Println("Object:", *obj.Key)
+		}
+		return true
+	})
+	if err != nil {
+		fmt.Println("failed to list objects", err)
+		return
+	}
+}

vendor/github.com/aws/aws-sdk-go/example/service/s3/listObjectsConcurrently/README.md

@@ -0,0 +1,13 @@
+## Example
+
+This is an example using the AWS SDK for Go concurrently to list the encrypted objects in the S3 buckets owned by an account.
+
+## Usage
+
+The example's `accounts` string slice contains a list of the SharedCredentials profiles which will be used to look up the buckets owned by each profile. Each bucket's objects will be queried.
+
+```
+AWS_REGION=us-east-1 go run -tags example listObjectsConcurrentlv.go
+```
+
+

vendor/github.com/aws/aws-sdk-go/example/service/s3/listObjectsConcurrently/listObjectsConcurrently.go

@@ -0,0 +1,236 @@
+// +build example
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/s3"
+)
+
+func exit(msg ...interface{}) {
+	fmt.Fprintln(os.Stderr, msg...)
+	os.Exit(1)
+}
+
+// Lists all encrypted objects owned by an account. The `accounts` string
+// contains a list of profiles to use.
+//
+// Usage:
+// listObjectsConcurrentlv
+func main() {
+	accounts := []string{"default", "default2", "otherprofile"}
+
+	// Spin off a worker for each account to retrieve that account's
+	bucketCh := make(chan *Bucket, 5)
+	var wg sync.WaitGroup
+	for _, acc := range accounts {
+		wg.Add(1)
+		go func(acc string) {
+			defer wg.Done()
+
+			sess, err := session.NewSessionWithOptions(session.Options{
+				Profile: acc,
+			})
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to create session for account, %s, %v\n", acc, err)
+				return
+			}
+			if err = getAccountBuckets(sess, bucketCh, acc); err != nil {
+				fmt.Fprintf(os.Stderr, "failed to get account %s's bucket info, %v\n", acc, err)
+			}
+		}(acc)
+	}
+	// Spin off a goroutine which will wait until all account buckets have been collected and
+	// added to the bucketCh. Close the bucketCh so the for range below will exit once all
+	// bucket info is printed.
+	go func() {
+		wg.Wait()
+		close(bucketCh)
+	}()
+
+	// Receive from the bucket channel printing the information for each bucket to the console
+	// when the bucketCh channel is drained.
+	buckets := []*Bucket{}
+	for b := range bucketCh {
+		buckets = append(buckets, b)
+	}
+
+	sortBuckets(buckets)
+	for _, b := range buckets {
+		if b.Error != nil {
+			fmt.Printf("Bucket %s, owned by: %s, failed: %v\n", b.Name, b.Owner, b.Error)
+			continue
+		}
+
+		encObjs := b.encryptedObjects()
+		fmt.Printf("Bucket: %s, owned by: %s, total objects: %d, failed objects: %d, encrypted objects: %d\n",
+			b.Name, b.Owner, len(b.Objects), len(b.ErrObjects), len(encObjs))
+		if len(encObjs) > 0 {
+			for _, encObj := range encObjs {
+				fmt.Printf("\t%s %s:%s/%s\n", encObj.EncryptionType, b.Region, b.Name, encObj.Key)
+			}
+		}
+	}
+}
+
+func sortBuckets(buckets []*Bucket) {
+	s := sortalbeBuckets(buckets)
+	sort.Sort(s)
+}
+
+type sortalbeBuckets []*Bucket
+
+func (s sortalbeBuckets) Len() int      { return len(s) }
+func (s sortalbeBuckets) Swap(a, b int) { s[a], s[b] = s[b], s[a] }
+func (s sortalbeBuckets) Less(a, b int) bool {
+	if s[a].Owner == s[b].Owner && s[a].Name < s[b].Name {
+		return true
+	}
+
+	if s[a].Owner < s[b].Owner {
+		return true
+	}
+
+	return false
+}
+
+func getAccountBuckets(sess *session.Session, bucketCh chan<- *Bucket, owner string) error {
+	svc := s3.New(sess)
+	buckets, err := listBuckets(svc)
+	if err != nil {
+		return fmt.Errorf("failed to list buckets, %v", err)
+	}
+	for _, bucket := range buckets {
+		bucket.Owner = owner
+		if bucket.Error != nil {
+			continue
+		}
+
+		bckSvc := s3.New(sess, &aws.Config{
+			Region:      aws.String(bucket.Region),
+			Credentials: svc.Config.Credentials,
+		})
+		bucketDetails(bckSvc, bucket)
+		bucketCh <- bucket
+	}
+
+	return nil
+}
+
+func bucketDetails(svc *s3.S3, bucket *Bucket) {
+	objs, errObjs, err := listBucketObjects(svc, bucket.Name)
+	if err != nil {
+		bucket.Error = err
+	} else {
+		bucket.Objects = objs
+		bucket.ErrObjects = errObjs
+	}
+}
+
+// A Object provides details of an S3 object
+type Object struct {
+	Bucket         string
+	Key            string
+	Encrypted      bool
+	EncryptionType string
+}
+
+// An ErrObject provides details of the error occurred retrieving
+// an object's status.
+type ErrObject struct {
+	Bucket string
+	Key    string
+	Error  error
+}
+
+// A Bucket provides details about a bucket and its objects
+type Bucket struct {
+	Owner        string
+	Name         string
+	CreationDate time.Time
+	Region       string
+	Objects      []Object
+	Error        error
+	ErrObjects   []ErrObject
+}
+
+func (b *Bucket) encryptedObjects() []Object {
+	encObjs := []Object{}
+	for _, obj := range b.Objects {
+		if obj.Encrypted {
+			encObjs = append(encObjs, obj)
+		}
+	}
+	return encObjs
+}
+
+func listBuckets(svc *s3.S3) ([]*Bucket, error) {
+	res, err := svc.ListBuckets(&s3.ListBucketsInput{})
+	if err != nil {
+		return nil, err
+	}
+
+	buckets := make([]*Bucket, len(res.Buckets))
+	for i, b := range res.Buckets {
+		buckets[i] = &Bucket{
+			Name:         *b.Name,
+			CreationDate: *b.CreationDate,
+		}
+
+		locRes, err := svc.GetBucketLocation(&s3.GetBucketLocationInput{
+			Bucket: b.Name,
+		})
+		if err != nil {
+			buckets[i].Error = err
+			continue
+		}
+
+		if locRes.LocationConstraint == nil {
+			buckets[i].Region = "us-east-1"
+		} else {
+			buckets[i].Region = *locRes.LocationConstraint
+		}
+	}
+
+	return buckets, nil
+}
+
+func listBucketObjects(svc *s3.S3, bucket string) ([]Object, []ErrObject, error) {
+	listRes, err := svc.ListObjects(&s3.ListObjectsInput{
+		Bucket: &bucket,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	objs := make([]Object, 0, len(listRes.Contents))
+	errObjs := []ErrObject{}
+	for _, listObj := range listRes.Contents {
+		objData, err := svc.HeadObject(&s3.HeadObjectInput{
+			Bucket: &bucket,
+			Key:    listObj.Key,
+		})
+
+		if err != nil {
+			errObjs = append(errObjs, ErrObject{Bucket: bucket, Key: *listObj.Key, Error: err})
+			continue
+		}
+
+		obj := Object{Bucket: bucket, Key: *listObj.Key}
+		if objData.ServerSideEncryption != nil {
+			obj.Encrypted = true
+			obj.EncryptionType = *objData.ServerSideEncryption
+		}
+
+		objs = append(objs, obj)
+	}
+
+	return objs, errObjs, nil
+}

vendor/github.com/aws/aws-sdk-go/example/service/s3/putObjectAcl/README.md

@@ -0,0 +1,40 @@
+# Example
+
+putObjectAcl is an example using the AWS SDK for Go to put an ACL on an S3 object.
+
+# Usage
+
+```sh
+putBucketAcl <params>
+	-region <region> // required
+	-bucket <bucket> // required
+	-key <key> // required
+	-owner-name <owner-name>
+	-owner-id <owner-id>
+	-grantee-type <some type> // required
+	-uri <uri to group>
+	-email <email address>
+	-user-id <user-id>
+	-display-name <display name>
+```
+
+```sh
+go run -tags example putObjectAcl.go 
+	-bucket <bucket> 
+	-key <key> 
+	-owner-name <name> 
+	-owner-id <id>
+	-grantee-type <some type>
+	-user-id <user-id>
+```
+
+Depending on the type is used depends on which of the three, `uri`, `email`, or `user-id`, needs to be used.
+* `s3.TypeCanonicalUser`: `user-id` or `display-name` must be used
+* `s3.TypeAmazonCustomerByEmail`: `email` must be used
+* `s3.TypeGroup`: `uri` must be used
+
+Output:
+```
+success {
+} nil
+```

vendor/github.com/aws/aws-sdk-go/example/service/s3/putObjectAcl/putObjectAcl.go

@@ -0,0 +1,91 @@
+// +build example
+
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/s3"
+)
+
+// Put an ACL on an S3 object
+//
+// Usage:
+// putBucketAcl <params>
+//	-region <region> // required
+//	-bucket <bucket> // required
+//	-key <key> // required
+//	-owner-name <owner-name>
+//	-owner-id <owner-id>
+//	-grantee-type <some type> // required
+//	-uri <uri to group>
+//	-email <email address>
+//	-user-id <user-id>
+func main() {
+	regionPtr := flag.String("region", "", "region of your request")
+	bucketPtr := flag.String("bucket", "", "name of your bucket")
+	keyPtr := flag.String("key", "", "of your object")
+	ownerNamePtr := flag.String("owner-name", "", "of your request")
+	ownerIDPtr := flag.String("owner-id", "", "of your request")
+	granteeTypePtr := flag.String("grantee-type", "", "of your request")
+	uriPtr := flag.String("uri", "", "of your grantee type")
+	emailPtr := flag.String("email", "", "of your grantee type")
+	userPtr := flag.String("user-id", "", "of your grantee type")
+	displayNamePtr := flag.String("display-name", "", "of your grantee type")
+	flag.Parse()
+
+	// Based off the type, fields must be excluded.
+	switch *granteeTypePtr {
+	case s3.TypeCanonicalUser:
+		emailPtr, uriPtr = nil, nil
+		if *displayNamePtr == "" {
+			displayNamePtr = nil
+		}
+
+		if *userPtr == "" {
+			userPtr = nil
+		}
+	case s3.TypeAmazonCustomerByEmail:
+		uriPtr, userPtr = nil, nil
+	case s3.TypeGroup:
+		emailPtr, userPtr = nil, nil
+	}
+
+	sess := session.Must(session.NewSession(&aws.Config{
+		Region: regionPtr,
+	}))
+
+	svc := s3.New(sess)
+
+	resp, err := svc.PutObjectAcl(&s3.PutObjectAclInput{
+		Bucket: bucketPtr,
+		Key:    keyPtr,
+		AccessControlPolicy: &s3.AccessControlPolicy{
+			Owner: &s3.Owner{
+				DisplayName: ownerNamePtr,
+				ID:          ownerIDPtr,
+			},
+			Grants: []*s3.Grant{
+				{
+					Grantee: &s3.Grantee{
+						Type:         granteeTypePtr,
+						DisplayName:  displayNamePtr,
+						URI:          uriPtr,
+						EmailAddress: emailPtr,
+						ID:           userPtr,
+					},
+					Permission: aws.String(s3.BucketLogsPermissionFullControl),
+				},
+			},
+		},
+	})
+
+	if err != nil {
+		fmt.Println("failed", err)
+	} else {
+		fmt.Println("success", resp)
+	}
+}

vendor/github.com/aws/aws-sdk-go/example/service/sqs/mockingClientsForTests/README.md

@@ -0,0 +1,9 @@
+# Example
+
+This example shows how the SDK's API interfaces can be used by your code instead of the concrete service client type directly. Using this pattern allows you to mock out your code's usage of the SDK's service client for testing.
+
+# Usage
+
+Use the `go test` tool to verify the `Queue` type's `GetMessages` function correctly unmarshals the SQS message responses.
+
+`go test -tags example ifaceExample.go`

vendor/github.com/aws/aws-sdk-go/example/service/sqs/mockingClientsForTests/ifaceExample.go

@@ -0,0 +1,79 @@
+// +build example
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "Queue URL required.")
+		os.Exit(1)
+	}
+
+	sess := session.Must(session.NewSession())
+
+	q := Queue{
+		Client: sqs.New(sess),
+		URL:    os.Args[1],
+	}
+
+	msgs, err := q.GetMessages(20)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	fmt.Println("Messages:")
+	for _, msg := range msgs {
+		fmt.Printf("%s>%s: %s\n", msg.From, msg.To, msg.Msg)
+	}
+}
+
+// Queue provides the ability to handle SQS messages.
+type Queue struct {
+	Client sqsiface.SQSAPI
+	URL    string
+}
+
+// Message is a concrete representation of the SQS message
+type Message struct {
+	From string `json:"from"`
+	To   string `json:"to"`
+	Msg  string `json:"msg"`
+}
+
+// GetMessages returns the parsed messages from SQS if any. If an error
+// occurs that error will be returned.
+func (q *Queue) GetMessages(waitTimeout int64) ([]Message, error) {
+	params := sqs.ReceiveMessageInput{
+		QueueUrl: aws.String(q.URL),
+	}
+	if waitTimeout > 0 {
+		params.WaitTimeSeconds = aws.Int64(waitTimeout)
+	}
+	resp, err := q.Client.ReceiveMessage(&params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get messages, %v", err)
+	}
+
+	msgs := make([]Message, len(resp.Messages))
+	for i, msg := range resp.Messages {
+		parsedMsg := Message{}
+		if err := json.Unmarshal([]byte(aws.StringValue(msg.Body)), &parsedMsg); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal message, %v", err)
+		}
+
+		msgs[i] = parsedMsg
+	}
+
+	return msgs, nil
+}

vendor/github.com/aws/aws-sdk-go/example/service/sqs/mockingClientsForTests/ifaceExample_test.go

@@ -0,0 +1,65 @@
+// +build example
+
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/sqs"
+	"github.com/aws/aws-sdk-go/service/sqs/sqsiface"
+)
+
+type mockedReceiveMsgs struct {
+	sqsiface.SQSAPI
+	Resp sqs.ReceiveMessageOutput
+}
+
+func (m mockedReceiveMsgs) ReceiveMessage(in *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) {
+	// Only need to return mocked response output
+	return &m.Resp, nil
+}
+
+func TestQueueGetMessage(t *testing.T) {
+	cases := []struct {
+		Resp     sqs.ReceiveMessageOutput
+		Expected []Message
+	}{
+		{ // Case 1, expect parsed responses
+			Resp: sqs.ReceiveMessageOutput{
+				Messages: []*sqs.Message{
+					{Body: aws.String(`{"from":"user_1","to":"room_1","msg":"Hello!"}`)},
+					{Body: aws.String(`{"from":"user_2","to":"room_1","msg":"Hi user_1 :)"}`)},
+				},
+			},
+			Expected: []Message{
+				{From: "user_1", To: "room_1", Msg: "Hello!"},
+				{From: "user_2", To: "room_1", Msg: "Hi user_1 :)"},
+			},
+		},
+		{ // Case 2, not messages returned
+			Resp:     sqs.ReceiveMessageOutput{},
+			Expected: []Message{},
+		},
+	}
+
+	for i, c := range cases {
+		q := Queue{
+			Client: mockedReceiveMsgs{Resp: c.Resp},
+			URL:    fmt.Sprintf("mockURL_%d", i),
+		}
+		msgs, err := q.GetMessages(20)
+		if err != nil {
+			t.Fatalf("%d, unexpected error, %v", i, err)
+		}
+		if a, e := len(msgs), len(c.Expected); a != e {
+			t.Fatalf("%d, expected %d messages, got %d", i, e, a)
+		}
+		for j, msg := range msgs {
+			if a, e := msg, c.Expected[j]; a != e {
+				t.Errorf("%d, expected %v message, got %v", i, e, a)
+			}
+		}
+	}
+}