Update deps

Godeps/Godeps.json

@@ -7,7 +7,7 @@
 	"Deps": [
 		{
 			"ImportPath": "github.com/armon/go-metrics",
-			"Rev": "b2d95e5291cdbc26997d1301a5e467ecbb240e25"
+			"Rev": "6c5fa0d8f48f4661c9ba8709799c88d425ad20f0"
 		},
 		{
 			"ImportPath": "github.com/armon/go-radix",
@@ -15,68 +15,68 @@
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/aws",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/endpoints",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/ec2query",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/query",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/rest",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/restxml",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/internal/signer/v4",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/service/iam",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/aws/aws-sdk-go/service/s3",
-			"Comment": "v0.9.0rc1-13-g87dbf7e",
+			"Comment": "v0.9.9-3-g7553d52",
-			"Rev": "87dbf7e29df163bd17d9cea9a03cb75eb8b76d29"
+			"Rev": "7553d5227962c0f226768d0435881e99ec0cab35"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-etcd/etcd",
-			"Comment": "v2.0.0-28-g126041e",
+			"Comment": "v2.0.0-34-gde3514f",
-			"Rev": "126041ef7b24a28359a12f8bf7f6a7db6756113d"
+			"Rev": "de3514f25635bbfb024fdaf2a8d5f67378492675"
 		},
 		{
 			"ImportPath": "github.com/dgrijalva/jwt-go",
-			"Comment": "v2.3.0-1-g9fe8afe",
+			"Comment": "v2.3.0-4-gc1da563",
-			"Rev": "9fe8afe96d32468fba230b8b22acea86251f0506"
+			"Rev": "c1da56349675b292d3200463e2c88b9aa5e02391"
 		},
 		{
 			"ImportPath": "github.com/duosecurity/duo_api_golang",
@@ -93,13 +93,13 @@
 		},
 		{
 			"ImportPath": "github.com/go-sql-driver/mysql",
-			"Comment": "v1.2-118-g3dd7008",
+			"Comment": "v1.2-119-g527bcd5",
-			"Rev": "3dd7008ac1529aca1bcd8a9db75228a71ba23cac"
+			"Rev": "527bcd55aab2e53314f1a150922560174b493034"
 		},
 		{
 			"ImportPath": "github.com/gocql/gocql",
-			"Comment": "1st_gen_framing-225-g9d122d6",
+			"Comment": "1st_gen_framing-268-g2641ef0",
-			"Rev": "9d122d6ceec00b4b73bfb70de5587cdee7078d17"
+			"Rev": "2641ef08fabdc0182465a14a4f23f1521acb2834"
 		},
 		{
 			"ImportPath": "github.com/golang/snappy",
@@ -107,7 +107,7 @@
 		},
 		{
 			"ImportPath": "github.com/google/go-github/github",
-			"Rev": "7277108aa3e8823e0e028f6c74aea2f4ce4a1b5a"
+			"Rev": "0d67682ce830f252a1d56215f39b71199036361d"
 		},
 		{
 			"ImportPath": "github.com/google/go-querystring/query",
@@ -115,8 +115,8 @@
 		},
 		{
 			"ImportPath": "github.com/hashicorp/consul/api",
-			"Comment": "v0.5.2-216-g134db62",
+			"Comment": "v0.5.2-313-gde08067",
-			"Rev": "134db6293762848681fc9244343bbd19f61d8149"
+			"Rev": "de080672fee9e6104572eeea89eccdca135bb918"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/errwrap",
@@ -124,7 +124,7 @@
 		},
 		{
 			"ImportPath": "github.com/hashicorp/go-multierror",
-			"Rev": "56912fb08d85084aa318edcf2bba735b97cf35c5"
+			"Rev": "d30f09973e19c1dfcd120b2d9c4f168e68d6b5d5"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/go-syslog",
@@ -136,7 +136,7 @@
 		},
 		{
 			"ImportPath": "github.com/hashicorp/hcl",
-			"Rev": "54864211433d45cb780682431585b3e573b49e4a"
+			"Rev": "4de51957ef8d4aba6e285ddfc587633bbfc7c0e8"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/logutils",
@@ -161,7 +161,7 @@
 		},
 		{
 			"ImportPath": "github.com/mitchellh/go-homedir",
-			"Rev": "1f6da4a72e57d4e7edd4a7295a585e0a3999a2d4"
+			"Rev": "df55a15e5ce646808815381b3db47a8c66ea62f4"
 		},
 		{
 			"ImportPath": "github.com/mitchellh/mapstructure",
@@ -173,8 +173,8 @@
 		},
 		{
 			"ImportPath": "github.com/ryanuber/columnize",
-			"Comment": "v2.0.1-6-g44cb478",
+			"Comment": "v2.0.1-8-g983d3a5",
-			"Rev": "44cb4788b2ec3c3d158dd3d1b50aba7d66f4b59a"
+			"Rev": "983d3a5fab1bf04d1b412465d2d9f8430e2e917e"
 		},
 		{
 			"ImportPath": "github.com/samuel/go-zookeeper/zk",
@@ -182,7 +182,7 @@
 		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "5abd4e96a45c386928ed2ca2a7ef63e2533e18ec"
+			"Rev": "1d5269ed4e89d423d40362a0914e1c99adb13cc8"
 		},
 		{
 			"ImportPath": "github.com/vaughan0/go-ini",
@@ -190,35 +190,35 @@
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/cast5",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/curve25519",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/openpgp",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/ssh",
-			"Rev": "81bf7719a6b7ce9b665598222362b50122dfc13b"
+			"Rev": "aedad9a179ec1ea11b7064c57cbc6dc30d7724ec"
 		},
 		{
 			"ImportPath": "golang.org/x/net/context",
-			"Rev": "66f0418ca41253f8d1a024eb9754e9441a8e79b9"
+			"Rev": "db8e4de5b2d6653f66aea53094624468caad15d2"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "397fe7649477ff2e8ced8fc0b2696f781e53745a"
+			"Rev": "82de3fe653a61c1b0174fba87c5f1ca06226ed51"
 		},
 		{
 			"ImportPath": "gopkg.in/asn1-ber.v1",
@@ -227,7 +227,7 @@
 		},
 		{
 			"ImportPath": "gopkg.in/inf.v0",
-			"Rev": "c85f1217d51339c0fa3a498cc8b2075de695dae6"
+			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
 		}
 	]
 }

Godeps/_workspace/src/github.com/armon/go-metrics/datadog/dogstatsd.go

@@ -0,0 +1,109 @@
+package datadog
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/DataDog/datadog-go/statsd"
+)
+
+// DogStatsdSink provides a MetricSink that can be used
+// with a dogstatsd server. It utilizes the Dogstatsd client at github.com/DataDog/datadog-go/statsd
+type DogStatsdSink struct {
+	client            *statsd.Client
+	hostName          string
+	propagateHostname bool
+}
+
+// NewDogStatsdSink is used to create a new DogStatsdSink with sane defaults
+func NewDogStatsdSink(addr string, hostName string) (*DogStatsdSink, error) {
+	client, err := statsd.New(addr)
+	if err != nil {
+		return nil, err
+	}
+	sink := &DogStatsdSink{
+		client:            client,
+		hostName:          hostName,
+		propagateHostname: false,
+	}
+	return sink, nil
+}
+
+// SetTags sets common tags on the Dogstatsd Client that will be sent
+// along with all dogstatsd packets.
+// Ref: http://docs.datadoghq.com/guides/dogstatsd/#tags
+func (s *DogStatsdSink) SetTags(tags []string) {
+	s.client.Tags = tags
+}
+
+// EnableHostnamePropagation forces a Dogstatsd `host` tag with the value specified by `s.HostName`
+// Since the go-metrics package has its own mechanism for attaching a hostname to metrics,
+// setting the `propagateHostname` flag ensures that `s.HostName` overrides the host tag naively set by the DogStatsd server
+func (s *DogStatsdSink) EnableHostNamePropagation() {
+	s.propagateHostname = true
+}
+
+func (s *DogStatsdSink) flattenKey(parts []string) string {
+	joined := strings.Join(parts, ".")
+	return strings.Map(func(r rune) rune {
+		switch r {
+		case ':':
+			fallthrough
+		case ' ':
+			return '_'
+		default:
+			return r
+		}
+	}, joined)
+}
+
+func (s *DogStatsdSink) parseKey(key []string) ([]string, []string) {
+	// Since DogStatsd supports dimensionality via tags on metric keys, this sink's approach is to splice the hostname out of the key in favor of a `host` tag
+	// The `host` tag is either forced here, or set downstream by the DogStatsd server
+
+	var tags []string
+	hostName := s.hostName
+
+	//Splice the hostname out of the key
+	for i, el := range key {
+		if el == hostName {
+			key = append(key[:i], key[i+1:]...)
+		}
+	}
+
+	if s.propagateHostname {
+		tags = append(tags, fmt.Sprintf("host:%s", hostName))
+	}
+	return key, tags
+}
+
+// Implementation of methods in the MetricSink interface
+
+func (s *DogStatsdSink) SetGauge(key []string, val float32) {
+	key, tags := s.parseKey(key)
+	flatKey := s.flattenKey(key)
+
+	rate := 1.0
+	s.client.Gauge(flatKey, float64(val), tags, rate)
+}
+
+func (s *DogStatsdSink) IncrCounter(key []string, val float32) {
+	key, tags := s.parseKey(key)
+	flatKey := s.flattenKey(key)
+
+	rate := 1.0
+	s.client.Count(flatKey, int64(val), tags, rate)
+}
+
+// EmitKey is not implemented since DogStatsd does not provide a metric type that holds an
+// arbitrary number of values
+func (s *DogStatsdSink) EmitKey(key []string, val float32) {
+}
+
+func (s *DogStatsdSink) AddSample(key []string, val float32) {
+	key, tags := s.parseKey(key)
+	flatKey := s.flattenKey(key)
+
+	rate := 1.0
+	s.client.TimeInMilliseconds(flatKey, float64(val), tags, rate)
+}

Godeps/_workspace/src/github.com/armon/go-metrics/inmem_signal_test.go

@@ -1,46 +0,0 @@
-package metrics
-
-import (
-	"bytes"
-	"os"
-	"strings"
-	"syscall"
-	"testing"
-	"time"
-)
-
-func TestInmemSignal(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	inm := NewInmemSink(10*time.Millisecond, 50*time.Millisecond)
-	sig := NewInmemSignal(inm, syscall.SIGUSR1, buf)
-	defer sig.Stop()
-
-	inm.SetGauge([]string{"foo"}, 42)
-	inm.EmitKey([]string{"bar"}, 42)
-	inm.IncrCounter([]string{"baz"}, 42)
-	inm.AddSample([]string{"wow"}, 42)
-
-	// Wait for period to end
-	time.Sleep(15 * time.Millisecond)
-
-	// Send signal!
-	syscall.Kill(os.Getpid(), syscall.SIGUSR1)
-
-	// Wait for flush
-	time.Sleep(10 * time.Millisecond)
-
-	// Check the output
-	out := string(buf.Bytes())
-	if !strings.Contains(out, "[G] 'foo': 42") {
-		t.Fatalf("bad: %v", out)
-	}
-	if !strings.Contains(out, "[P] 'bar': 42") {
-		t.Fatalf("bad: %v", out)
-	}
-	if !strings.Contains(out, "[C] 'baz': Count: 1 Sum: 42") {
-		t.Fatalf("bad: %v", out)
-	}
-	if !strings.Contains(out, "[S] 'wow': Count: 1 Sum: 42") {
-		t.Fatalf("bad: %v", out)
-	}
-}

Godeps/_workspace/src/github.com/armon/go-metrics/inmem_test.go

@@ -1,104 +0,0 @@
-package metrics
-
-import (
-	"math"
-	"testing"
-	"time"
-)
-
-func TestInmemSink(t *testing.T) {
-	inm := NewInmemSink(10*time.Millisecond, 50*time.Millisecond)
-
-	data := inm.Data()
-	if len(data) != 1 {
-		t.Fatalf("bad: %v", data)
-	}
-
-	// Add data points
-	inm.SetGauge([]string{"foo", "bar"}, 42)
-	inm.EmitKey([]string{"foo", "bar"}, 42)
-	inm.IncrCounter([]string{"foo", "bar"}, 20)
-	inm.IncrCounter([]string{"foo", "bar"}, 22)
-	inm.AddSample([]string{"foo", "bar"}, 20)
-	inm.AddSample([]string{"foo", "bar"}, 22)
-
-	data = inm.Data()
-	if len(data) != 1 {
-		t.Fatalf("bad: %v", data)
-	}
-
-	intvM := data[0]
-	intvM.RLock()
-
-	if time.Now().Sub(intvM.Interval) > 10*time.Millisecond {
-		t.Fatalf("interval too old")
-	}
-	if intvM.Gauges["foo.bar"] != 42 {
-		t.Fatalf("bad val: %v", intvM.Gauges)
-	}
-	if intvM.Points["foo.bar"][0] != 42 {
-		t.Fatalf("bad val: %v", intvM.Points)
-	}
-
-	agg := intvM.Counters["foo.bar"]
-	if agg.Count != 2 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.Sum != 42 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.SumSq != 884 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.Min != 20 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.Max != 22 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.Mean() != 21 {
-		t.Fatalf("bad val: %v", agg)
-	}
-	if agg.Stddev() != math.Sqrt(2) {
-		t.Fatalf("bad val: %v", agg)
-	}
-
-	if agg.LastUpdated.IsZero() {
-		t.Fatalf("agg.LastUpdated is not set: %v", agg)
-	}
-
-	diff := time.Now().Sub(agg.LastUpdated).Seconds()
-	if diff > 1 {
-		t.Fatalf("time diff too great: %f", diff)
-	}
-
-	if agg = intvM.Samples["foo.bar"]; agg == nil {
-		t.Fatalf("missing sample")
-	}
-
-	intvM.RUnlock()
-
-	for i := 1; i < 10; i++ {
-		time.Sleep(10 * time.Millisecond)
-		inm.SetGauge([]string{"foo", "bar"}, 42)
-		data = inm.Data()
-		if len(data) != min(i+1, 5) {
-			t.Fatalf("bad: %v", data)
-		}
-	}
-
-	// Should not exceed 5 intervals!
-	time.Sleep(10 * time.Millisecond)
-	inm.SetGauge([]string{"foo", "bar"}, 42)
-	data = inm.Data()
-	if len(data) != 5 {
-		t.Fatalf("bad: %v", data)
-	}
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

Godeps/_workspace/src/github.com/armon/go-metrics/metrics_test.go

@@ -1,262 +0,0 @@
-package metrics
-
-import (
-	"reflect"
-	"runtime"
-	"testing"
-	"time"
-)
-
-func mockMetric() (*MockSink, *Metrics) {
-	m := &MockSink{}
-	met := &Metrics{sink: m}
-	return m, met
-}
-
-func TestMetrics_SetGauge(t *testing.T) {
-	m, met := mockMetric()
-	met.SetGauge([]string{"key"}, float32(1))
-	if m.keys[0][0] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.HostName = "test"
-	met.EnableHostname = true
-	met.SetGauge([]string{"key"}, float32(1))
-	if m.keys[0][0] != "test" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.EnableTypePrefix = true
-	met.SetGauge([]string{"key"}, float32(1))
-	if m.keys[0][0] != "gauge" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.ServiceName = "service"
-	met.SetGauge([]string{"key"}, float32(1))
-	if m.keys[0][0] != "service" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-}
-
-func TestMetrics_EmitKey(t *testing.T) {
-	m, met := mockMetric()
-	met.EmitKey([]string{"key"}, float32(1))
-	if m.keys[0][0] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.EnableTypePrefix = true
-	met.EmitKey([]string{"key"}, float32(1))
-	if m.keys[0][0] != "kv" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.ServiceName = "service"
-	met.EmitKey([]string{"key"}, float32(1))
-	if m.keys[0][0] != "service" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-}
-
-func TestMetrics_IncrCounter(t *testing.T) {
-	m, met := mockMetric()
-	met.IncrCounter([]string{"key"}, float32(1))
-	if m.keys[0][0] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.EnableTypePrefix = true
-	met.IncrCounter([]string{"key"}, float32(1))
-	if m.keys[0][0] != "counter" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.ServiceName = "service"
-	met.IncrCounter([]string{"key"}, float32(1))
-	if m.keys[0][0] != "service" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-}
-
-func TestMetrics_AddSample(t *testing.T) {
-	m, met := mockMetric()
-	met.AddSample([]string{"key"}, float32(1))
-	if m.keys[0][0] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.EnableTypePrefix = true
-	met.AddSample([]string{"key"}, float32(1))
-	if m.keys[0][0] != "sample" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.ServiceName = "service"
-	met.AddSample([]string{"key"}, float32(1))
-	if m.keys[0][0] != "service" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] != 1 {
-		t.Fatalf("")
-	}
-}
-
-func TestMetrics_MeasureSince(t *testing.T) {
-	m, met := mockMetric()
-	met.TimerGranularity = time.Millisecond
-	n := time.Now()
-	met.MeasureSince([]string{"key"}, n)
-	if m.keys[0][0] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] > 0.1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.TimerGranularity = time.Millisecond
-	met.EnableTypePrefix = true
-	met.MeasureSince([]string{"key"}, n)
-	if m.keys[0][0] != "timer" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] > 0.1 {
-		t.Fatalf("")
-	}
-
-	m, met = mockMetric()
-	met.TimerGranularity = time.Millisecond
-	met.ServiceName = "service"
-	met.MeasureSince([]string{"key"}, n)
-	if m.keys[0][0] != "service" || m.keys[0][1] != "key" {
-		t.Fatalf("")
-	}
-	if m.vals[0] > 0.1 {
-		t.Fatalf("")
-	}
-}
-
-func TestMetrics_EmitRuntimeStats(t *testing.T) {
-	runtime.GC()
-	m, met := mockMetric()
-	met.emitRuntimeStats()
-
-	if m.keys[0][0] != "runtime" || m.keys[0][1] != "num_goroutines" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[0] <= 1 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[1][0] != "runtime" || m.keys[1][1] != "alloc_bytes" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[1] <= 40000 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[2][0] != "runtime" || m.keys[2][1] != "sys_bytes" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[2] <= 100000 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[3][0] != "runtime" || m.keys[3][1] != "malloc_count" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[3] <= 100 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[4][0] != "runtime" || m.keys[4][1] != "free_count" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[4] <= 100 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[5][0] != "runtime" || m.keys[5][1] != "heap_objects" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[5] <= 100 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[6][0] != "runtime" || m.keys[6][1] != "total_gc_pause_ns" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[6] <= 100000 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[7][0] != "runtime" || m.keys[7][1] != "total_gc_runs" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[7] <= 1 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-
-	if m.keys[8][0] != "runtime" || m.keys[8][1] != "gc_pause_ns" {
-		t.Fatalf("bad key %v", m.keys)
-	}
-	if m.vals[8] <= 1000 {
-		t.Fatalf("bad val: %v", m.vals)
-	}
-}
-
-func TestInsert(t *testing.T) {
-	k := []string{"hi", "bob"}
-	exp := []string{"hi", "there", "bob"}
-	out := insert(1, "there", k)
-	if !reflect.DeepEqual(exp, out) {
-		t.Fatalf("bad insert %v %v", exp, out)
-	}
-}

Godeps/_workspace/src/github.com/armon/go-metrics/sink_test.go

@@ -1,120 +0,0 @@
-package metrics
-
-import (
-	"reflect"
-	"testing"
-)
-
-type MockSink struct {
-	keys [][]string
-	vals []float32
-}
-
-func (m *MockSink) SetGauge(key []string, val float32) {
-	m.keys = append(m.keys, key)
-	m.vals = append(m.vals, val)
-}
-func (m *MockSink) EmitKey(key []string, val float32) {
-	m.keys = append(m.keys, key)
-	m.vals = append(m.vals, val)
-}
-func (m *MockSink) IncrCounter(key []string, val float32) {
-	m.keys = append(m.keys, key)
-	m.vals = append(m.vals, val)
-}
-func (m *MockSink) AddSample(key []string, val float32) {
-	m.keys = append(m.keys, key)
-	m.vals = append(m.vals, val)
-}
-
-func TestFanoutSink_Gauge(t *testing.T) {
-	m1 := &MockSink{}
-	m2 := &MockSink{}
-	fh := &FanoutSink{m1, m2}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	fh.SetGauge(k, v)
-
-	if !reflect.DeepEqual(m1.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m2.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m1.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-	if !reflect.DeepEqual(m2.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func TestFanoutSink_Key(t *testing.T) {
-	m1 := &MockSink{}
-	m2 := &MockSink{}
-	fh := &FanoutSink{m1, m2}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	fh.EmitKey(k, v)
-
-	if !reflect.DeepEqual(m1.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m2.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m1.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-	if !reflect.DeepEqual(m2.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func TestFanoutSink_Counter(t *testing.T) {
-	m1 := &MockSink{}
-	m2 := &MockSink{}
-	fh := &FanoutSink{m1, m2}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	fh.IncrCounter(k, v)
-
-	if !reflect.DeepEqual(m1.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m2.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m1.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-	if !reflect.DeepEqual(m2.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func TestFanoutSink_Sample(t *testing.T) {
-	m1 := &MockSink{}
-	m2 := &MockSink{}
-	fh := &FanoutSink{m1, m2}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	fh.AddSample(k, v)
-
-	if !reflect.DeepEqual(m1.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m2.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m1.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-	if !reflect.DeepEqual(m2.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}

Godeps/_workspace/src/github.com/armon/go-metrics/start_test.go

@@ -1,110 +0,0 @@
-package metrics
-
-import (
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestDefaultConfig(t *testing.T) {
-	conf := DefaultConfig("service")
-	if conf.ServiceName != "service" {
-		t.Fatalf("Bad name")
-	}
-	if conf.HostName == "" {
-		t.Fatalf("missing hostname")
-	}
-	if !conf.EnableHostname || !conf.EnableRuntimeMetrics {
-		t.Fatalf("expect true")
-	}
-	if conf.EnableTypePrefix {
-		t.Fatalf("expect false")
-	}
-	if conf.TimerGranularity != time.Millisecond {
-		t.Fatalf("bad granularity")
-	}
-	if conf.ProfileInterval != time.Second {
-		t.Fatalf("bad interval")
-	}
-}
-
-func Test_GlobalMetrics_SetGauge(t *testing.T) {
-	m := &MockSink{}
-	globalMetrics = &Metrics{sink: m}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	SetGauge(k, v)
-
-	if !reflect.DeepEqual(m.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func Test_GlobalMetrics_EmitKey(t *testing.T) {
-	m := &MockSink{}
-	globalMetrics = &Metrics{sink: m}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	EmitKey(k, v)
-
-	if !reflect.DeepEqual(m.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func Test_GlobalMetrics_IncrCounter(t *testing.T) {
-	m := &MockSink{}
-	globalMetrics = &Metrics{sink: m}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	IncrCounter(k, v)
-
-	if !reflect.DeepEqual(m.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func Test_GlobalMetrics_AddSample(t *testing.T) {
-	m := &MockSink{}
-	globalMetrics = &Metrics{sink: m}
-
-	k := []string{"test"}
-	v := float32(42.0)
-	AddSample(k, v)
-
-	if !reflect.DeepEqual(m.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if !reflect.DeepEqual(m.vals[0], v) {
-		t.Fatalf("val not equal")
-	}
-}
-
-func Test_GlobalMetrics_MeasureSince(t *testing.T) {
-	m := &MockSink{}
-	globalMetrics = &Metrics{sink: m}
-	globalMetrics.TimerGranularity = time.Millisecond
-
-	k := []string{"test"}
-	now := time.Now()
-	MeasureSince(k, now)
-
-	if !reflect.DeepEqual(m.keys[0], k) {
-		t.Fatalf("key not equal")
-	}
-	if m.vals[0] > 0.1 {
-		t.Fatalf("val too large %v", m.vals[0])
-	}
-}

Godeps/_workspace/src/github.com/armon/go-metrics/statsd_test.go

@@ -1,105 +0,0 @@
-package metrics
-
-import (
-	"bufio"
-	"bytes"
-	"net"
-	"testing"
-	"time"
-)
-
-func TestStatsd_Flatten(t *testing.T) {
-	s := &StatsdSink{}
-	flat := s.flattenKey([]string{"a", "b", "c", "d"})
-	if flat != "a.b.c.d" {
-		t.Fatalf("Bad flat")
-	}
-}
-
-func TestStatsd_PushFullQueue(t *testing.T) {
-	q := make(chan string, 1)
-	q <- "full"
-
-	s := &StatsdSink{metricQueue: q}
-	s.pushMetric("omit")
-
-	out := <-q
-	if out != "full" {
-		t.Fatalf("bad val %v", out)
-	}
-
-	select {
-	case v := <-q:
-		t.Fatalf("bad val %v", v)
-	default:
-	}
-}
-
-func TestStatsd_Conn(t *testing.T) {
-	addr := "127.0.0.1:7524"
-	done := make(chan bool)
-	go func() {
-		list, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 7524})
-		if err != nil {
-			panic(err)
-		}
-		defer list.Close()
-		buf := make([]byte, 1500)
-		n, err := list.Read(buf)
-		if err != nil {
-			panic(err)
-		}
-		buf = buf[:n]
-		reader := bufio.NewReader(bytes.NewReader(buf))
-
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "gauge.val:1.000000|g\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "key.other:2.000000|kv\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "counter.me:3.000000|c\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "sample.slow_thingy:4.000000|ms\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		done <- true
-	}()
-	s, err := NewStatsdSink(addr)
-	if err != nil {
-		t.Fatalf("bad error")
-	}
-
-	s.SetGauge([]string{"gauge", "val"}, float32(1))
-	s.EmitKey([]string{"key", "other"}, float32(2))
-	s.IncrCounter([]string{"counter", "me"}, float32(3))
-	s.AddSample([]string{"sample", "slow thingy"}, float32(4))
-
-	select {
-	case <-done:
-		s.Shutdown()
-	case <-time.After(3 * time.Second):
-		t.Fatalf("timeout")
-	}
-}

Godeps/_workspace/src/github.com/armon/go-metrics/statsite_test.go

@@ -1,101 +0,0 @@
-package metrics
-
-import (
-	"bufio"
-	"net"
-	"testing"
-	"time"
-)
-
-func acceptConn(addr string) net.Conn {
-	ln, _ := net.Listen("tcp", addr)
-	conn, _ := ln.Accept()
-	return conn
-}
-
-func TestStatsite_Flatten(t *testing.T) {
-	s := &StatsiteSink{}
-	flat := s.flattenKey([]string{"a", "b", "c", "d"})
-	if flat != "a.b.c.d" {
-		t.Fatalf("Bad flat")
-	}
-}
-
-func TestStatsite_PushFullQueue(t *testing.T) {
-	q := make(chan string, 1)
-	q <- "full"
-
-	s := &StatsiteSink{metricQueue: q}
-	s.pushMetric("omit")
-
-	out := <-q
-	if out != "full" {
-		t.Fatalf("bad val %v", out)
-	}
-
-	select {
-	case v := <-q:
-		t.Fatalf("bad val %v", v)
-	default:
-	}
-}
-
-func TestStatsite_Conn(t *testing.T) {
-	addr := "localhost:7523"
-	done := make(chan bool)
-	go func() {
-		conn := acceptConn(addr)
-		reader := bufio.NewReader(conn)
-
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "gauge.val:1.000000|g\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "key.other:2.000000|kv\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "counter.me:3.000000|c\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		line, err = reader.ReadString('\n')
-		if err != nil {
-			t.Fatalf("unexpected err %s", err)
-		}
-		if line != "sample.slow_thingy:4.000000|ms\n" {
-			t.Fatalf("bad line %s", line)
-		}
-
-		conn.Close()
-		done <- true
-	}()
-	s, err := NewStatsiteSink(addr)
-	if err != nil {
-		t.Fatalf("bad error")
-	}
-
-	s.SetGauge([]string{"gauge", "val"}, float32(1))
-	s.EmitKey([]string{"key", "other"}, float32(2))
-	s.IncrCounter([]string{"counter", "me"}, float32(3))
-	s.AddSample([]string{"sample", "slow thingy"}, float32(4))
-
-	select {
-	case <-done:
-		s.Shutdown()
-	case <-time.After(3 * time.Second):
-		t.Fatalf("timeout")
-	}
-}

Godeps/_workspace/src/github.com/armon/go-radix/radix_test.go

@@ -1,319 +0,0 @@
-package radix
-
-import (
-	crand "crypto/rand"
-	"fmt"
-	"reflect"
-	"sort"
-	"testing"
-)
-
-func TestRadix(t *testing.T) {
-	var min, max string
-	inp := make(map[string]interface{})
-	for i := 0; i < 1000; i++ {
-		gen := generateUUID()
-		inp[gen] = i
-		if gen < min || i == 0 {
-			min = gen
-		}
-		if gen > max || i == 0 {
-			max = gen
-		}
-	}
-
-	r := NewFromMap(inp)
-	if r.Len() != len(inp) {
-		t.Fatalf("bad length: %v %v", r.Len(), len(inp))
-	}
-
-	r.Walk(func(k string, v interface{}) bool {
-		println(k)
-		return false
-	})
-
-	for k, v := range inp {
-		out, ok := r.Get(k)
-		if !ok {
-			t.Fatalf("missing key: %v", k)
-		}
-		if out != v {
-			t.Fatalf("value mis-match: %v %v", out, v)
-		}
-	}
-
-	// Check min and max
-	outMin, _, _ := r.Minimum()
-	if outMin != min {
-		t.Fatalf("bad minimum: %v %v", outMin, min)
-	}
-	outMax, _, _ := r.Maximum()
-	if outMax != max {
-		t.Fatalf("bad maximum: %v %v", outMax, max)
-	}
-
-	for k, v := range inp {
-		out, ok := r.Delete(k)
-		if !ok {
-			t.Fatalf("missing key: %v", k)
-		}
-		if out != v {
-			t.Fatalf("value mis-match: %v %v", out, v)
-		}
-	}
-	if r.Len() != 0 {
-		t.Fatalf("bad length: %v", r.Len())
-	}
-}
-
-func TestRoot(t *testing.T) {
-	r := New()
-	_, ok := r.Delete("")
-	if ok {
-		t.Fatalf("bad")
-	}
-	_, ok = r.Insert("", true)
-	if ok {
-		t.Fatalf("bad")
-	}
-	val, ok := r.Get("")
-	if !ok || val != true {
-		t.Fatalf("bad: %v", val)
-	}
-	val, ok = r.Delete("")
-	if !ok || val != true {
-		t.Fatalf("bad: %v", val)
-	}
-}
-
-func TestDelete(t *testing.T) {
-
-	r := New()
-
-	s := []string{"", "A", "AB"}
-
-	for _, ss := range s {
-		r.Insert(ss, true)
-	}
-
-	for _, ss := range s {
-		_, ok := r.Delete(ss)
-		if !ok {
-			t.Fatalf("bad %q", ss)
-		}
-	}
-}
-
-func TestLongestPrefix(t *testing.T) {
-	r := New()
-
-	keys := []string{
-		"",
-		"foo",
-		"foobar",
-		"foobarbaz",
-		"foobarbazzip",
-		"foozip",
-	}
-	for _, k := range keys {
-		r.Insert(k, nil)
-	}
-	if r.Len() != len(keys) {
-		t.Fatalf("bad len: %v %v", r.Len(), len(keys))
-	}
-
-	type exp struct {
-		inp string
-		out string
-	}
-	cases := []exp{
-		{"a", ""},
-		{"abc", ""},
-		{"fo", ""},
-		{"foo", "foo"},
-		{"foob", "foo"},
-		{"foobar", "foobar"},
-		{"foobarba", "foobar"},
-		{"foobarbaz", "foobarbaz"},
-		{"foobarbazzi", "foobarbaz"},
-		{"foobarbazzip", "foobarbazzip"},
-		{"foozi", "foo"},
-		{"foozip", "foozip"},
-		{"foozipzap", "foozip"},
-	}
-	for _, test := range cases {
-		m, _, ok := r.LongestPrefix(test.inp)
-		if !ok {
-			t.Fatalf("no match: %v", test)
-		}
-		if m != test.out {
-			t.Fatalf("mis-match: %v %v", m, test)
-		}
-	}
-}
-
-func TestWalkPrefix(t *testing.T) {
-	r := New()
-
-	keys := []string{
-		"foobar",
-		"foo/bar/baz",
-		"foo/baz/bar",
-		"foo/zip/zap",
-		"zipzap",
-	}
-	for _, k := range keys {
-		r.Insert(k, nil)
-	}
-	if r.Len() != len(keys) {
-		t.Fatalf("bad len: %v %v", r.Len(), len(keys))
-	}
-
-	type exp struct {
-		inp string
-		out []string
-	}
-	cases := []exp{
-		exp{
-			"f",
-			[]string{"foobar", "foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
-		},
-		exp{
-			"foo",
-			[]string{"foobar", "foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
-		},
-		exp{
-			"foob",
-			[]string{"foobar"},
-		},
-		exp{
-			"foo/",
-			[]string{"foo/bar/baz", "foo/baz/bar", "foo/zip/zap"},
-		},
-		exp{
-			"foo/b",
-			[]string{"foo/bar/baz", "foo/baz/bar"},
-		},
-		exp{
-			"foo/ba",
-			[]string{"foo/bar/baz", "foo/baz/bar"},
-		},
-		exp{
-			"foo/bar",
-			[]string{"foo/bar/baz"},
-		},
-		exp{
-			"foo/bar/baz",
-			[]string{"foo/bar/baz"},
-		},
-		exp{
-			"foo/bar/bazoo",
-			[]string{},
-		},
-		exp{
-			"z",
-			[]string{"zipzap"},
-		},
-	}
-
-	for _, test := range cases {
-		out := []string{}
-		fn := func(s string, v interface{}) bool {
-			out = append(out, s)
-			return false
-		}
-		r.WalkPrefix(test.inp, fn)
-		sort.Strings(out)
-		sort.Strings(test.out)
-		if !reflect.DeepEqual(out, test.out) {
-			t.Fatalf("mis-match: %v %v", out, test.out)
-		}
-	}
-}
-
-func TestWalkPath(t *testing.T) {
-	r := New()
-
-	keys := []string{
-		"foo",
-		"foo/bar",
-		"foo/bar/baz",
-		"foo/baz/bar",
-		"foo/zip/zap",
-		"zipzap",
-	}
-	for _, k := range keys {
-		r.Insert(k, nil)
-	}
-	if r.Len() != len(keys) {
-		t.Fatalf("bad len: %v %v", r.Len(), len(keys))
-	}
-
-	type exp struct {
-		inp string
-		out []string
-	}
-	cases := []exp{
-		exp{
-			"f",
-			[]string{},
-		},
-		exp{
-			"foo",
-			[]string{"foo"},
-		},
-		exp{
-			"foo/",
-			[]string{"foo"},
-		},
-		exp{
-			"foo/ba",
-			[]string{"foo"},
-		},
-		exp{
-			"foo/bar",
-			[]string{"foo", "foo/bar"},
-		},
-		exp{
-			"foo/bar/baz",
-			[]string{"foo", "foo/bar", "foo/bar/baz"},
-		},
-		exp{
-			"foo/bar/bazoo",
-			[]string{"foo", "foo/bar", "foo/bar/baz"},
-		},
-		exp{
-			"z",
-			[]string{},
-		},
-	}
-
-	for _, test := range cases {
-		out := []string{}
-		fn := func(s string, v interface{}) bool {
-			out = append(out, s)
-			return false
-		}
-		r.WalkPath(test.inp, fn)
-		sort.Strings(out)
-		sort.Strings(test.out)
-		if !reflect.DeepEqual(out, test.out) {
-			t.Fatalf("mis-match: %v %v", out, test.out)
-		}
-	}
-}
-
-// generateUUID is used to generate a random UUID
-func generateUUID() string {
-	buf := make([]byte, 16)
-	if _, err := crand.Read(buf); err != nil {
-		panic(fmt.Errorf("failed to read random bytes: %v", err))
-	}
-
-	return fmt.Sprintf("%08x-%04x-%04x-%04x-%12x",
-		buf[0:4],
-		buf[4:6],
-		buf[6:8],
-		buf[8:10],
-		buf[10:16])
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awserr/types.go

@@ -113,7 +113,7 @@ func newRequestError(err Error, statusCode int, requestID string) *requestError
 // 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]",
+	extra := fmt.Sprintf("status code: %d, request id: %s",
 		r.statusCode, r.requestID)
 	return SprintError(r.Code(), r.Message(), extra, r.OrigErr())
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/copy_test.go

@@ -1,201 +0,0 @@
-package awsutil_test
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/stretchr/testify/assert"
-)
-
-func ExampleCopy() {
-	type Foo struct {
-		A int
-		B []*string
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	f1 := &Foo{A: 1, B: []*string{&str1, &str2}}
-
-	// Do the copy
-	var f2 Foo
-	awsutil.Copy(&f2, f1)
-
-	// Print the result
-	fmt.Println(awsutil.Prettify(f2))
-
-	// Output:
-	// {
-	//   A: 1,
-	//   B: ["hello","bye bye"]
-	// }
-}
-
-func TestCopy(t *testing.T) {
-	type Foo struct {
-		A int
-		B []*string
-		C map[string]*int
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	int1 := 1
-	int2 := 2
-	f1 := &Foo{
-		A: 1,
-		B: []*string{&str1, &str2},
-		C: map[string]*int{
-			"A": &int1,
-			"B": &int2,
-		},
-	}
-
-	// Do the copy
-	var f2 Foo
-	awsutil.Copy(&f2, f1)
-
-	// Values are equal
-	assert.Equal(t, f2.A, f1.A)
-	assert.Equal(t, f2.B, f1.B)
-	assert.Equal(t, f2.C, f1.C)
-
-	// But pointers are not!
-	str3 := "nothello"
-	int3 := 57
-	f2.A = 100
-	f2.B[0] = &str3
-	f2.C["B"] = &int3
-	assert.NotEqual(t, f2.A, f1.A)
-	assert.NotEqual(t, f2.B, f1.B)
-	assert.NotEqual(t, f2.C, f1.C)
-}
-
-func TestCopyIgnoreNilMembers(t *testing.T) {
-	type Foo struct {
-		A *string
-		B []string
-		C map[string]string
-	}
-
-	f := &Foo{}
-	assert.Nil(t, f.A)
-	assert.Nil(t, f.B)
-	assert.Nil(t, f.C)
-
-	var f2 Foo
-	awsutil.Copy(&f2, f)
-	assert.Nil(t, f2.A)
-	assert.Nil(t, f2.B)
-	assert.Nil(t, f2.C)
-
-	fcopy := awsutil.CopyOf(f)
-	f3 := fcopy.(*Foo)
-	assert.Nil(t, f3.A)
-	assert.Nil(t, f3.B)
-	assert.Nil(t, f3.C)
-}
-
-func TestCopyPrimitive(t *testing.T) {
-	str := "hello"
-	var s string
-	awsutil.Copy(&s, &str)
-	assert.Equal(t, "hello", s)
-}
-
-func TestCopyNil(t *testing.T) {
-	var s string
-	awsutil.Copy(&s, nil)
-	assert.Equal(t, "", s)
-}
-
-func TestCopyReader(t *testing.T) {
-	var buf io.Reader = bytes.NewReader([]byte("hello world"))
-	var r io.Reader
-	awsutil.Copy(&r, buf)
-	b, err := ioutil.ReadAll(r)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("hello world"), b)
-
-	// empty bytes because this is not a deep copy
-	b, err = ioutil.ReadAll(buf)
-	assert.NoError(t, err)
-	assert.Equal(t, []byte(""), b)
-}
-
-func TestCopyDifferentStructs(t *testing.T) {
-	type SrcFoo struct {
-		A                int
-		B                []*string
-		C                map[string]*int
-		SrcUnique        string
-		SameNameDiffType int
-	}
-	type DstFoo struct {
-		A                int
-		B                []*string
-		C                map[string]*int
-		DstUnique        int
-		SameNameDiffType string
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	int1 := 1
-	int2 := 2
-	f1 := &SrcFoo{
-		A: 1,
-		B: []*string{&str1, &str2},
-		C: map[string]*int{
-			"A": &int1,
-			"B": &int2,
-		},
-		SrcUnique:        "unique",
-		SameNameDiffType: 1,
-	}
-
-	// Do the copy
-	var f2 DstFoo
-	awsutil.Copy(&f2, f1)
-
-	// Values are equal
-	assert.Equal(t, f2.A, f1.A)
-	assert.Equal(t, f2.B, f1.B)
-	assert.Equal(t, f2.C, f1.C)
-	assert.Equal(t, "unique", f1.SrcUnique)
-	assert.Equal(t, 1, f1.SameNameDiffType)
-	assert.Equal(t, 0, f2.DstUnique)
-	assert.Equal(t, "", f2.SameNameDiffType)
-}
-
-func ExampleCopyOf() {
-	type Foo struct {
-		A int
-		B []*string
-	}
-
-	// Create the initial value
-	str1 := "hello"
-	str2 := "bye bye"
-	f1 := &Foo{A: 1, B: []*string{&str1, &str2}}
-
-	// Do the copy
-	v := awsutil.CopyOf(f1)
-	var f2 *Foo = v.(*Foo)
-
-	// Print the result
-	fmt.Println(awsutil.Prettify(f2))
-
-	// Output:
-	// {
-	//   A: 1,
-	//   B: ["hello","bye bye"]
-	// }
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/awsutil/path_value_test.go

@@ -1,68 +0,0 @@
-package awsutil_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/stretchr/testify/assert"
-)
-
-type Struct struct {
-	A []Struct
-	z []Struct
-	B *Struct
-	D *Struct
-	C string
-}
-
-var data = Struct{
-	A: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}},
-	z: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}},
-	B: &Struct{B: &Struct{C: "terminal"}, D: &Struct{C: "terminal2"}},
-	C: "initial",
-}
-
-func TestValueAtPathSuccess(t *testing.T) {
-	assert.Equal(t, []interface{}{"initial"}, awsutil.ValuesAtPath(data, "C"))
-	assert.Equal(t, []interface{}{"value1"}, awsutil.ValuesAtPath(data, "A[0].C"))
-	assert.Equal(t, []interface{}{"value2"}, awsutil.ValuesAtPath(data, "A[1].C"))
-	assert.Equal(t, []interface{}{"value3"}, awsutil.ValuesAtPath(data, "A[2].C"))
-	assert.Equal(t, []interface{}{"value3"}, awsutil.ValuesAtAnyPath(data, "a[2].c"))
-	assert.Equal(t, []interface{}{"value3"}, awsutil.ValuesAtPath(data, "A[-1].C"))
-	assert.Equal(t, []interface{}{"value1", "value2", "value3"}, awsutil.ValuesAtPath(data, "A[].C"))
-	assert.Equal(t, []interface{}{"terminal"}, awsutil.ValuesAtPath(data, "B . B . C"))
-	assert.Equal(t, []interface{}{"terminal", "terminal2"}, awsutil.ValuesAtPath(data, "B.*.C"))
-	assert.Equal(t, []interface{}{"initial"}, awsutil.ValuesAtPath(data, "A.D.X || C"))
-}
-
-func TestValueAtPathFailure(t *testing.T) {
-	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, "C.x"))
-	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, ".x"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "X.Y.Z"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "A[100].C"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "A[3].C"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(data, "B.B.C.Z"))
-	assert.Equal(t, []interface{}(nil), awsutil.ValuesAtPath(data, "z[-1].C"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(nil, "A.B.C"))
-	assert.Equal(t, []interface{}{}, awsutil.ValuesAtPath(Struct{}, "A"))
-}
-
-func TestSetValueAtPathSuccess(t *testing.T) {
-	var s Struct
-	awsutil.SetValueAtPath(&s, "C", "test1")
-	awsutil.SetValueAtPath(&s, "B.B.C", "test2")
-	awsutil.SetValueAtPath(&s, "B.D.C", "test3")
-	assert.Equal(t, "test1", s.C)
-	assert.Equal(t, "test2", s.B.B.C)
-	assert.Equal(t, "test3", s.B.D.C)
-
-	awsutil.SetValueAtPath(&s, "B.*.C", "test0")
-	assert.Equal(t, "test0", s.B.B.C)
-	assert.Equal(t, "test0", s.B.D.C)
-
-	var s2 Struct
-	awsutil.SetValueAtAnyPath(&s2, "b.b.c", "test0")
-	assert.Equal(t, "test0", s2.B.B.C)
-	awsutil.SetValueAtAnyPath(&s2, "A", []Struct{{}})
-	assert.Equal(t, []Struct{{}}, s2.A)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/config.go

@@ -2,6 +2,7 @@ package aws
 
 import (
 	"net/http"
+	"time"
 
 	"github.com/aws/aws-sdk-go/aws/credentials"
 )
@@ -11,10 +12,10 @@ import (
 const DefaultRetries = -1
 
 // A Config provides service configuration for service clients. By default,
-// all clients will use the {DefaultConfig} structure.
+// all clients will use the {defaults.DefaultConfig} structure.
 type Config struct {
 	// The credentials object to use when signing requests. Defaults to
-	// {DefaultChainCredentials}.
+	// {defaults.DefaultChainCredentials}.
 	Credentials *credentials.Credentials
 
 	// An optional endpoint URL (hostname only or fully qualified URI)
@@ -73,6 +74,8 @@ type Config struct {
 	// @see http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html
 	//   Amazon S3: Virtual Hosting of Buckets
 	S3ForcePathStyle *bool
+
+	SleepDelay func(time.Duration)
 }
 
 // NewConfig returns a new Config pointer that can be chained with builder methods to
@@ -161,6 +164,13 @@ func (c *Config) WithS3ForcePathStyle(force bool) *Config {
 	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
+}
+
 // Merge returns a new Config with the other Config's attribute values merged into
 // this Config. If the other Config's attribute is nil it will not be merged into
 // the new Config to be returned.
@@ -215,6 +225,10 @@ func (c Config) Merge(other *Config) *Config {
 		dst.S3ForcePathStyle = other.S3ForcePathStyle
 	}
 
+	if other.SleepDelay != nil {
+		dst.SleepDelay = other.SleepDelay
+	}
+
 	return &dst
 }
 

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/config_test.go

@@ -1,80 +0,0 @@
-package aws
-
-import (
-	"net/http"
-	"reflect"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/credentials"
-)
-
-var testCredentials = credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-
-var copyTestConfig = Config{
-	Credentials:             testCredentials,
-	Endpoint:                String("CopyTestEndpoint"),
-	Region:                  String("COPY_TEST_AWS_REGION"),
-	DisableSSL:              Bool(true),
-	HTTPClient:              http.DefaultClient,
-	LogLevel:                LogLevel(LogDebug),
-	Logger:                  NewDefaultLogger(),
-	MaxRetries:              Int(DefaultRetries),
-	DisableParamValidation:  Bool(true),
-	DisableComputeChecksums: Bool(true),
-	S3ForcePathStyle:        Bool(true),
-}
-
-func TestCopy(t *testing.T) {
-	want := copyTestConfig
-	got := copyTestConfig.Copy()
-	if !reflect.DeepEqual(*got, want) {
-		t.Errorf("Copy() = %+v", got)
-		t.Errorf("    want %+v", want)
-	}
-}
-
-func TestCopyReturnsNewInstance(t *testing.T) {
-	want := copyTestConfig
-	got := copyTestConfig.Copy()
-	if got == &want {
-		t.Errorf("Copy() = %p; want different instance as source %p", got, &want)
-	}
-}
-
-var mergeTestZeroValueConfig = Config{}
-
-var mergeTestConfig = Config{
-	Credentials:             testCredentials,
-	Endpoint:                String("MergeTestEndpoint"),
-	Region:                  String("MERGE_TEST_AWS_REGION"),
-	DisableSSL:              Bool(true),
-	HTTPClient:              http.DefaultClient,
-	LogLevel:                LogLevel(LogDebug),
-	Logger:                  NewDefaultLogger(),
-	MaxRetries:              Int(10),
-	DisableParamValidation:  Bool(true),
-	DisableComputeChecksums: Bool(true),
-	S3ForcePathStyle:        Bool(true),
-}
-
-var mergeTests = []struct {
-	cfg  *Config
-	in   *Config
-	want *Config
-}{
-	{&Config{}, nil, &Config{}},
-	{&Config{}, &mergeTestZeroValueConfig, &Config{}},
-	{&Config{}, &mergeTestConfig, &mergeTestConfig},
-}
-
-func TestMerge(t *testing.T) {
-	for i, tt := range mergeTests {
-		got := tt.cfg.Merge(tt.in)
-		if !reflect.DeepEqual(got, tt.want) {
-			t.Errorf("Config %d %+v", i, tt.cfg)
-			t.Errorf("   Merge(%+v)", tt.in)
-			t.Errorf("     got %+v", got)
-			t.Errorf("    want %+v", tt.want)
-		}
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/convert_types_test.go

@@ -1,437 +0,0 @@
-package aws
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-var testCasesStringSlice = [][]string{
-	{"a", "b", "c", "d", "e"},
-	{"a", "b", "", "", "e"},
-}
-
-func TestStringSlice(t *testing.T) {
-	for idx, in := range testCasesStringSlice {
-		if in == nil {
-			continue
-		}
-		out := StringSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := StringValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesStringValueSlice = [][]*string{
-	{String("a"), String("b"), nil, String("c")},
-}
-
-func TestStringValueSlice(t *testing.T) {
-	for idx, in := range testCasesStringValueSlice {
-		if in == nil {
-			continue
-		}
-		out := StringValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := StringSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesStringMap = []map[string]string{
-	{"a": "1", "b": "2", "c": "3"},
-}
-
-func TestStringMap(t *testing.T) {
-	for idx, in := range testCasesStringMap {
-		if in == nil {
-			continue
-		}
-		out := StringMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := StringValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesBoolSlice = [][]bool{
-	{true, true, false, false},
-}
-
-func TestBoolSlice(t *testing.T) {
-	for idx, in := range testCasesBoolSlice {
-		if in == nil {
-			continue
-		}
-		out := BoolSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := BoolValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesBoolValueSlice = [][]*bool{}
-
-func TestBoolValueSlice(t *testing.T) {
-	for idx, in := range testCasesBoolValueSlice {
-		if in == nil {
-			continue
-		}
-		out := BoolValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := BoolSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesBoolMap = []map[string]bool{
-	{"a": true, "b": false, "c": true},
-}
-
-func TestBoolMap(t *testing.T) {
-	for idx, in := range testCasesBoolMap {
-		if in == nil {
-			continue
-		}
-		out := BoolMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := BoolValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesIntSlice = [][]int{
-	{1, 2, 3, 4},
-}
-
-func TestIntSlice(t *testing.T) {
-	for idx, in := range testCasesIntSlice {
-		if in == nil {
-			continue
-		}
-		out := IntSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := IntValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesIntValueSlice = [][]*int{}
-
-func TestIntValueSlice(t *testing.T) {
-	for idx, in := range testCasesIntValueSlice {
-		if in == nil {
-			continue
-		}
-		out := IntValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := IntSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesIntMap = []map[string]int{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestIntMap(t *testing.T) {
-	for idx, in := range testCasesIntMap {
-		if in == nil {
-			continue
-		}
-		out := IntMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := IntValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesInt64Slice = [][]int64{
-	{1, 2, 3, 4},
-}
-
-func TestInt64Slice(t *testing.T) {
-	for idx, in := range testCasesInt64Slice {
-		if in == nil {
-			continue
-		}
-		out := Int64Slice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Int64ValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesInt64ValueSlice = [][]*int64{}
-
-func TestInt64ValueSlice(t *testing.T) {
-	for idx, in := range testCasesInt64ValueSlice {
-		if in == nil {
-			continue
-		}
-		out := Int64ValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := Int64Slice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesInt64Map = []map[string]int64{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestInt64Map(t *testing.T) {
-	for idx, in := range testCasesInt64Map {
-		if in == nil {
-			continue
-		}
-		out := Int64Map(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Int64ValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesFloat64Slice = [][]float64{
-	{1, 2, 3, 4},
-}
-
-func TestFloat64Slice(t *testing.T) {
-	for idx, in := range testCasesFloat64Slice {
-		if in == nil {
-			continue
-		}
-		out := Float64Slice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Float64ValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesFloat64ValueSlice = [][]*float64{}
-
-func TestFloat64ValueSlice(t *testing.T) {
-	for idx, in := range testCasesFloat64ValueSlice {
-		if in == nil {
-			continue
-		}
-		out := Float64ValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := Float64Slice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesFloat64Map = []map[string]float64{
-	{"a": 3, "b": 2, "c": 1},
-}
-
-func TestFloat64Map(t *testing.T) {
-	for idx, in := range testCasesFloat64Map {
-		if in == nil {
-			continue
-		}
-		out := Float64Map(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := Float64ValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesTimeSlice = [][]time.Time{
-	{time.Now(), time.Now().AddDate(100, 0, 0)},
-}
-
-func TestTimeSlice(t *testing.T) {
-	for idx, in := range testCasesTimeSlice {
-		if in == nil {
-			continue
-		}
-		out := TimeSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := TimeValueSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}
-
-var testCasesTimeValueSlice = [][]*time.Time{}
-
-func TestTimeValueSlice(t *testing.T) {
-	for idx, in := range testCasesTimeValueSlice {
-		if in == nil {
-			continue
-		}
-		out := TimeValueSlice(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			if in[i] == nil {
-				assert.Empty(t, out[i], "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, *(in[i]), out[i], "Unexpected value at idx %d", idx)
-			}
-		}
-
-		out2 := TimeSlice(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		for i := range out2 {
-			if in[i] == nil {
-				assert.Empty(t, *(out2[i]), "Unexpected value at idx %d", idx)
-			} else {
-				assert.Equal(t, in[i], out2[i], "Unexpected value at idx %d", idx)
-			}
-		}
-	}
-}
-
-var testCasesTimeMap = []map[string]time.Time{
-	{"a": time.Now().AddDate(-100, 0, 0), "b": time.Now()},
-}
-
-func TestTimeMap(t *testing.T) {
-	for idx, in := range testCasesTimeMap {
-		if in == nil {
-			continue
-		}
-		out := TimeMap(in)
-		assert.Len(t, out, len(in), "Unexpected len at idx %d", idx)
-		for i := range out {
-			assert.Equal(t, in[i], *(out[i]), "Unexpected value at idx %d", idx)
-		}
-
-		out2 := TimeValueMap(out)
-		assert.Len(t, out2, len(in), "Unexpected len at idx %d", idx)
-		assert.Equal(t, in, out2, "Unexpected value at idx %d", idx)
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/handlers.go

@@ -1,4 +1,4 @@
-package service
+package corehandlers
 
 import (
 	"bytes"
@@ -9,16 +9,12 @@ import (
 	"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/request"
 )
 
-var sleepDelay = func(delay time.Duration) {
-	time.Sleep(delay)
-}
-
 // Interface for matching types which also have a Len method.
 type lener interface {
 	Len() int
@@ -27,7 +23,7 @@ type lener interface {
 // BuildContentLength 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.
-func BuildContentLength(r *Request) {
+var BuildContentLengthHandler = request.NamedHandler{"core.BuildContentLengthHandler", func(r *request.Request) {
 	if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" {
 		length, _ := strconv.ParseInt(slength, 10, 64)
 		r.HTTPRequest.ContentLength = length
@@ -41,27 +37,27 @@ func BuildContentLength(r *Request) {
 	case lener:
 		length = int64(body.Len())
 	case io.Seeker:
-		r.bodyStart, _ = body.Seek(0, 1)
+		r.BodyStart, _ = body.Seek(0, 1)
 		end, _ := body.Seek(0, 2)
-		body.Seek(r.bodyStart, 0) // make sure to seek back to original location
+		body.Seek(r.BodyStart, 0) // make sure to seek back to original location
-		length = end - r.bodyStart
+		length = end - r.BodyStart
 	default:
 		panic("Cannot get length of body, must provide `ContentLength`")
 	}
 
 	r.HTTPRequest.ContentLength = length
 	r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))
-}
+}}
 
 // UserAgentHandler is a request handler for injecting User agent into requests.
-func UserAgentHandler(r *Request) {
+var UserAgentHandler = request.NamedHandler{"core.UserAgentHandler", func(r *request.Request) {
 	r.HTTPRequest.Header.Set("User-Agent", aws.SDKName+"/"+aws.SDKVersion)
-}
+}}
 
-var reStatusCode = regexp.MustCompile(`^(\d+)`)
+var reStatusCode = regexp.MustCompile(`^(\d{3})`)
 
 // SendHandler is a request handler to send service request using HTTP client.
-func SendHandler(r *Request) {
+var SendHandler = request.NamedHandler{"core.SendHandler", func(r *request.Request) {
 	var err error
 	r.HTTPResponse, err = r.Service.Config.HTTPClient.Do(r.HTTPRequest)
 	if err != nil {
@@ -69,8 +65,8 @@ func SendHandler(r *Request) {
 		// 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 {
+		if e, ok := err.(*url.Error); ok && e.Err != nil {
-			if s := reStatusCode.FindStringSubmatch(e.Error()); s != nil {
+			if s := reStatusCode.FindStringSubmatch(e.Err.Error()); s != nil {
 				code, _ := strconv.ParseInt(s[1], 10, 64)
 				r.HTTPResponse = &http.Response{
 					StatusCode: int(code),
@@ -93,66 +89,48 @@ func SendHandler(r *Request) {
 		r.Error = awserr.New("RequestError", "send request failed", err)
 		r.Retryable = aws.Bool(true) // network errors are retryable
 	}
-}
+}}
 
 // ValidateResponseHandler is a request handler to validate service response.
-func ValidateResponseHandler(r *Request) {
+var ValidateResponseHandler = request.NamedHandler{"core.ValidateResponseHandler", 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.
-func AfterRetryHandler(r *Request) {
+var AfterRetryHandler = request.NamedHandler{"core.AfterRetryHandler", 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 {
-		r.Retryable = aws.Bool(r.Service.ShouldRetry(r))
+		r.Retryable = aws.Bool(r.ShouldRetry(r))
 	}
 
 	if r.WillRetry() {
-		r.RetryDelay = r.Service.RetryRules(r)
+		r.RetryDelay = r.RetryRules(r)
-		sleepDelay(r.RetryDelay)
+		r.Service.Config.SleepDelay(r.RetryDelay)
 
 		// 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.Error != nil {
+		if r.IsErrorExpired() {
-			if err, ok := r.Error.(awserr.Error); ok {
+			r.Service.Config.Credentials.Expire()
-				if isCodeExpiredCreds(err.Code()) {
-					r.Config.Credentials.Expire()
-				}
-			}
 		}
 
 		r.RetryCount++
 		r.Error = nil
 	}
-}
+}}
-
-var (
-	// ErrMissingRegion is an error that is returned if region configuration is
-	// not found.
-	//
-	// @readonly
-	ErrMissingRegion error = 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.
-	//
-	// @readonly
-	ErrMissingEndpoint error = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", 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.
-func ValidateEndpointHandler(r *Request) {
+var ValidateEndpointHandler = request.NamedHandler{"core.ValidateEndpointHandler", func(r *request.Request) {
 	if r.Service.SigningRegion == "" && aws.StringValue(r.Service.Config.Region) == "" {
-		r.Error = ErrMissingRegion
+		r.Error = aws.ErrMissingRegion
 	} else if r.Service.Endpoint == "" {
-		r.Error = ErrMissingEndpoint
+		r.Error = aws.ErrMissingEndpoint
 	}
-}
+}}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go

@@ -0,0 +1,144 @@
+package corehandlers
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+// ValidateParameters 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{"core.ValidateParametersHandler", func(r *request.Request) {
+	if r.ParamsFilled() {
+		v := validator{errors: []string{}}
+		v.validateAny(reflect.ValueOf(r.Params), "")
+
+		if count := len(v.errors); count > 0 {
+			format := "%d validation errors:\n- %s"
+			msg := fmt.Sprintf(format, count, strings.Join(v.errors, "\n- "))
+			r.Error = awserr.New("InvalidParameter", msg, nil)
+		}
+	}
+}}
+
+// A validator validates values. Collects validations errors which occurs.
+type validator struct {
+	errors []string
+}
+
+// validateAny will validate any struct, slice or map type. All validations
+// are also performed recursively for nested types.
+func (v *validator) validateAny(value reflect.Value, path string) {
+	value = reflect.Indirect(value)
+	if !value.IsValid() {
+		return
+	}
+
+	switch value.Kind() {
+	case reflect.Struct:
+		v.validateStruct(value, path)
+	case reflect.Slice:
+		for i := 0; i < value.Len(); i++ {
+			v.validateAny(value.Index(i), path+fmt.Sprintf("[%d]", i))
+		}
+	case reflect.Map:
+		for _, n := range value.MapKeys() {
+			v.validateAny(value.MapIndex(n), path+fmt.Sprintf("[%q]", n.String()))
+		}
+	}
+}
+
+// validateStruct will validate the struct value's fields. If the structure has
+// nested types those types will be validated also.
+func (v *validator) validateStruct(value reflect.Value, path string) {
+	prefix := "."
+	if path == "" {
+		prefix = ""
+	}
+
+	for i := 0; i < value.Type().NumField(); i++ {
+		f := value.Type().Field(i)
+		if strings.ToLower(f.Name[0:1]) == f.Name[0:1] {
+			continue
+		}
+		fvalue := value.FieldByName(f.Name)
+
+		err := validateField(f, fvalue, validateFieldRequired, validateFieldMin)
+		if err != nil {
+			v.errors = append(v.errors, fmt.Sprintf("%s: %s", err.Error(), path+prefix+f.Name))
+			continue
+		}
+
+		v.validateAny(fvalue, path+prefix+f.Name)
+	}
+}
+
+type validatorFunc func(f reflect.StructField, fvalue reflect.Value) error
+
+func validateField(f reflect.StructField, fvalue reflect.Value, funcs ...validatorFunc) error {
+	for _, fn := range funcs {
+		if err := fn(f, fvalue); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Validates that a field has a valid value provided for required fields.
+func validateFieldRequired(f reflect.StructField, fvalue reflect.Value) error {
+	if f.Tag.Get("required") == "" {
+		return nil
+	}
+
+	switch fvalue.Kind() {
+	case reflect.Ptr, reflect.Slice, reflect.Map:
+		if fvalue.IsNil() {
+			return fmt.Errorf("missing required parameter")
+		}
+	default:
+		if !fvalue.IsValid() {
+			return fmt.Errorf("missing required parameter")
+		}
+	}
+	return nil
+}
+
+// Validates that if a value is provided for a field, that value must be at
+// least a minimum length.
+func validateFieldMin(f reflect.StructField, fvalue reflect.Value) error {
+	minStr := f.Tag.Get("min")
+	if minStr == "" {
+		return nil
+	}
+	min, _ := strconv.ParseInt(minStr, 10, 64)
+
+	kind := fvalue.Kind()
+	if kind == reflect.Ptr {
+		if fvalue.IsNil() {
+			return nil
+		}
+		fvalue = fvalue.Elem()
+	}
+
+	switch fvalue.Kind() {
+	case reflect.String:
+		if int64(fvalue.Len()) < min {
+			return fmt.Errorf("field too short, minimum length %d", min)
+		}
+	case reflect.Slice, reflect.Map:
+		if fvalue.IsNil() {
+			return nil
+		}
+		if int64(fvalue.Len()) < min {
+			return fmt.Errorf("field too short, minimum length %d", min)
+		}
+
+		// TODO min can also apply to number minimum value.
+
+	}
+	return nil
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/chain_provider_test.go

@@ -1,73 +0,0 @@
-package credentials
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestChainProviderGet(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-			&stubProvider{
-				creds: Value{
-					AccessKeyID:     "AKID",
-					SecretAccessKey: "SECRET",
-					SessionToken:    "",
-				},
-			},
-		},
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect session token to be empty")
-}
-
-func TestChainProviderIsExpired(t *testing.T) {
-	stubProvider := &stubProvider{expired: true}
-	p := &ChainProvider{
-		Providers: []Provider{
-			stubProvider,
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired to be true before any Retrieve")
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-
-	stubProvider.expired = true
-	assert.True(t, p.IsExpired(), "Expect return of expired provider")
-
-	_, err = p.Retrieve()
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-}
-
-func TestChainProviderWithNoProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}
-
-func TestChainProviderWithNoValidProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/credentials_test.go

@@ -1,62 +0,0 @@
-package credentials
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/stretchr/testify/assert"
-)
-
-type stubProvider struct {
-	creds   Value
-	expired bool
-	err     error
-}
-
-func (s *stubProvider) Retrieve() (Value, error) {
-	s.expired = false
-	return s.creds, s.err
-}
-func (s *stubProvider) IsExpired() bool {
-	return s.expired
-}
-
-func TestCredentialsGet(t *testing.T) {
-	c := NewCredentials(&stubProvider{
-		creds: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-		expired: true,
-	})
-
-	creds, err := c.Get()
-	assert.Nil(t, err, "Expected no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect session token to be empty")
-}
-
-func TestCredentialsGetWithError(t *testing.T) {
-	c := NewCredentials(&stubProvider{err: awserr.New("provider error", "", nil), expired: true})
-
-	_, err := c.Get()
-	assert.Equal(t, "provider error", err.(awserr.Error).Code(), "Expected provider error")
-}
-
-func TestCredentialsExpire(t *testing.T) {
-	stub := &stubProvider{}
-	c := NewCredentials(stub)
-
-	stub.expired = false
-	assert.True(t, c.IsExpired(), "Expected to start out expired")
-	c.Expire()
-	assert.True(t, c.IsExpired(), "Expected to be expired")
-
-	c.forceRefresh = false
-	assert.False(t, c.IsExpired(), "Expected not to be expired")
-
-	stub.expired = true
-	assert.True(t, c.IsExpired(), "Expected to be expired")
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds/ec2_role_provider_test.go

@@ -1,161 +0,0 @@
-package ec2rolecreds_test
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-)
-
-const credsRespTmpl = `{
-  "Code": "Success",
-  "Type": "AWS-HMAC",
-  "AccessKeyId" : "accessKey",
-  "SecretAccessKey" : "secret",
-  "Token" : "token",
-  "Expiration" : "%s",
-  "LastUpdated" : "2009-11-23T0:00:00Z"
-}`
-
-const credsFailRespTmpl = `{
-  "Code": "ErrorCode",
-  "Message": "ErrorMsg",
-  "LastUpdated": "2009-11-23T0:00:00Z"
-}`
-
-func initTestServer(expireOn string, failAssume bool) *httptest.Server {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/latest/meta-data/iam/security-credentials" {
-			fmt.Fprintln(w, "RoleName")
-		} else if r.URL.Path == "/latest/meta-data/iam/security-credentials/RoleName" {
-			if failAssume {
-				fmt.Fprintf(w, credsFailRespTmpl)
-			} else {
-				fmt.Fprintf(w, credsRespTmpl, expireOn)
-			}
-		} else {
-			http.Error(w, "bad request", http.StatusBadRequest)
-		}
-	}))
-
-	return server
-}
-
-func TestEC2RoleProvider(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEC2RoleProviderFailAssume(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", true)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-
-	creds, err := p.Retrieve()
-	assert.Error(t, err, "Expect error")
-
-	e := err.(awserr.Error)
-	assert.Equal(t, "ErrorCode", e.Code())
-	assert.Equal(t, "ErrorMsg", e.Message())
-	assert.Nil(t, e.OrigErr())
-
-	assert.Equal(t, "", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEC2RoleProviderIsExpired(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 15, 21, 26, 0, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.")
-
-	p.CurrentTime = func() time.Time {
-		return time.Date(3014, 12, 15, 21, 26, 0, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired.")
-}
-
-func TestEC2RoleProviderExpiryWindowIsExpired(t *testing.T) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client:       ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")}),
-		ExpiryWindow: time.Hour * 1,
-	}
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 15, 0, 51, 37, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.")
-
-	p.CurrentTime = func() time.Time {
-		return time.Date(2014, 12, 16, 0, 55, 37, 0, time.UTC)
-	}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired.")
-}
-
-func BenchmarkEC2RoleProvider(b *testing.B) {
-	server := initTestServer("2014-12-16T01:51:37Z", false)
-	defer server.Close()
-
-	p := &ec2rolecreds.EC2RoleProvider{
-		Client: ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")}),
-	}
-	_, err := p.Retrieve()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_, err := p.Retrieve()
-			if err != nil {
-				b.Fatal(err)
-			}
-		}
-	})
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/env_provider_test.go

@@ -1,70 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"os"
-	"testing"
-)
-
-func TestEnvProviderRetrieve(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-	os.Setenv("AWS_SESSION_TOKEN", "token")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "access", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestEnvProviderIsExpired(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-	os.Setenv("AWS_SESSION_TOKEN", "token")
-
-	e := EnvProvider{}
-
-	assert.True(t, e.IsExpired(), "Expect creds to be expired before retrieve.")
-
-	_, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, e.IsExpired(), "Expect creds to not be expired after retrieve.")
-}
-
-func TestEnvProviderNoAccessKeyID(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Equal(t, ErrAccessKeyIDNotFound, err, "ErrAccessKeyIDNotFound expected, but was %#v error: %#v", creds, err)
-}
-
-func TestEnvProviderNoSecretAccessKey(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY_ID", "access")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Equal(t, ErrSecretAccessKeyNotFound, err, "ErrSecretAccessKeyNotFound expected, but was %#v error: %#v", creds, err)
-}
-
-func TestEnvProviderAlternateNames(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_ACCESS_KEY", "access")
-	os.Setenv("AWS_SECRET_KEY", "secret")
-
-	e := EnvProvider{}
-	creds, err := e.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "access", creds.AccessKeyID, "Expected access key ID")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expected secret access key")
-	assert.Empty(t, creds.SessionToken, "Expected no token")
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/shared_credentials_provider_test.go

@@ -1,90 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"os"
-	"testing"
-)
-
-func TestSharedCredentialsProvider(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestSharedCredentialsProviderIsExpired(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-
-	assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve")
-
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve")
-}
-
-func TestSharedCredentialsProviderWithAWS_SHARED_CREDENTIALS_FILE(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_SHARED_CREDENTIALS_FILE", "example.ini")
-	p := SharedCredentialsProvider{}
-	creds, err := p.Retrieve()
-
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "token", creds.SessionToken, "Expect session token to match")
-}
-
-func TestSharedCredentialsProviderWithAWS_PROFILE(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("AWS_PROFILE", "no_token")
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no token")
-}
-
-func TestSharedCredentialsProviderWithoutTokenFromProfile(t *testing.T) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: "no_token"}
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "accessKey", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "secret", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no token")
-}
-
-func BenchmarkSharedCredentialsProvider(b *testing.B) {
-	os.Clearenv()
-
-	p := SharedCredentialsProvider{Filename: "example.ini", Profile: ""}
-	_, err := p.Retrieve()
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_, err := p.Retrieve()
-			if err != nil {
-				b.Fatal(err)
-			}
-		}
-	})
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/static_provider_test.go

@@ -1,34 +0,0 @@
-package credentials
-
-import (
-	"github.com/stretchr/testify/assert"
-	"testing"
-)
-
-func TestStaticProviderGet(t *testing.T) {
-	s := StaticProvider{
-		Value: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-	}
-
-	creds, err := s.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect no session token")
-}
-
-func TestStaticProviderIsExpired(t *testing.T) {
-	s := StaticProvider{
-		Value: Value{
-			AccessKeyID:     "AKID",
-			SecretAccessKey: "SECRET",
-			SessionToken:    "",
-		},
-	}
-
-	assert.False(t, s.IsExpired(), "Expect static credentials to never expire")
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider.go

@@ -54,6 +54,9 @@ type AssumeRoleProvider struct {
 	// 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
+
 	// 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
@@ -104,6 +107,7 @@ func (p *AssumeRoleProvider) Retrieve() (credentials.Value, error) {
 		DurationSeconds: aws.Int64(int64(p.Duration / time.Second)),
 		RoleArn:         aws.String(p.RoleARN),
 		RoleSessionName: aws.String(p.RoleSessionName),
+		ExternalId:      p.ExternalID,
 	})
 
 	if err != nil {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/credentials/stscreds/assume_role_provider_test.go

@@ -1,59 +0,0 @@
-package stscreds
-
-import (
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/sts"
-	"github.com/stretchr/testify/assert"
-)
-
-type stubSTS struct {
-}
-
-func (s *stubSTS) AssumeRole(input *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) {
-	expiry := time.Now().Add(60 * time.Minute)
-	return &sts.AssumeRoleOutput{
-		Credentials: &sts.Credentials{
-			// Just reflect the role arn to the provider.
-			AccessKeyId:     input.RoleArn,
-			SecretAccessKey: aws.String("assumedSecretAccessKey"),
-			SessionToken:    aws.String("assumedSessionToken"),
-			Expiration:      &expiry,
-		},
-	}, nil
-}
-
-func TestAssumeRoleProvider(t *testing.T) {
-	stub := &stubSTS{}
-	p := &AssumeRoleProvider{
-		Client:  stub,
-		RoleARN: "roleARN",
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-
-	assert.Equal(t, "roleARN", creds.AccessKeyID, "Expect access key ID to be reflected role ARN")
-	assert.Equal(t, "assumedSecretAccessKey", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Equal(t, "assumedSessionToken", creds.SessionToken, "Expect session token to match")
-}
-
-func BenchmarkAssumeRoleProvider(b *testing.B) {
-	stub := &stubSTS{}
-	p := &AssumeRoleProvider{
-		Client:  stub,
-		RoleARN: "roleARN",
-	}
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_, err := p.Retrieve()
-			if err != nil {
-				b.Fatal(err)
-			}
-		}
-	})
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/defaults/defaults.go

@@ -35,4 +35,5 @@ var DefaultConfig = aws.NewConfig().
 	WithHTTPClient(http.DefaultClient).
 	WithMaxRetries(aws.DefaultRetries).
 	WithLogger(aws.NewDefaultLogger()).
-	WithLogLevel(aws.LogOff)
+	WithLogLevel(aws.LogOff).
+	WithSleepDelay(time.Sleep)

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api.go

@@ -3,19 +3,19 @@ package ec2metadata
 import (
 	"path"
 
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 // GetMetadata uses the path provided to request
 func (c *Client) GetMetadata(p string) (string, error) {
-	op := &service.Operation{
+	op := &request.Operation{
 		Name:       "GetMetadata",
 		HTTPMethod: "GET",
 		HTTPPath:   path.Join("/", "meta-data", p),
 	}
 
 	output := &metadataOutput{}
-	req := service.NewRequest(c.Service, op, nil, output)
+	req := request.New(c.Service.ServiceInfo, c.Service.Handlers, c.Service.Retryer, op, nil, output)
 
 	return output.Content, req.Send()
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/api_test.go

@@ -1,100 +0,0 @@
-package ec2metadata_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/service"
-)
-
-func initTestServer(path string, resp string) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.RequestURI != path {
-			http.Error(w, "not found", http.StatusNotFound)
-			return
-		}
-
-		w.Write([]byte(resp))
-	}))
-}
-
-func TestEndpoint(t *testing.T) {
-	c := ec2metadata.New(&ec2metadata.Config{})
-	op := &service.Operation{
-		Name:       "GetMetadata",
-		HTTPMethod: "GET",
-		HTTPPath:   path.Join("/", "meta-data", "testpath"),
-	}
-
-	req := service.NewRequest(c.Service, op, nil, nil)
-	assert.Equal(t, "http://169.254.169.254/latest", req.Endpoint)
-	assert.Equal(t, "http://169.254.169.254/latest/meta-data/testpath", req.HTTPRequest.URL.String())
-}
-
-func TestGetMetadata(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/some/path",
-		"success", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	resp, err := c.GetMetadata("some/path")
-
-	assert.NoError(t, err)
-	assert.Equal(t, "success", resp)
-}
-
-func TestGetRegion(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/placement/availability-zone",
-		"us-west-2a", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	region, err := c.Region()
-
-	assert.NoError(t, err)
-	assert.Equal(t, "us-west-2", region)
-}
-
-func TestMetadataAvailable(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/instance-id",
-		"instance-id",
-	)
-	defer server.Close()
-	c := ec2metadata.New(&ec2metadata.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	available := c.Available()
-
-	assert.True(t, available)
-}
-
-func TestMetadataNotAvailable(t *testing.T) {
-	c := ec2metadata.New(nil)
-	c.Handlers.Send.Clear()
-	c.Handlers.Send.PushBack(func(r *service.Request) {
-		r.HTTPResponse = &http.Response{
-			StatusCode: int(0),
-			Status:     http.StatusText(int(0)),
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-		}
-		r.Error = awserr.New("RequestError", "send request failed", nil)
-		r.Retryable = aws.Bool(true) // network errors are retryable
-	})
-
-	available := c.Available()
-
-	assert.False(t, available)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/ec2metadata/service.go

@@ -7,7 +7,9 @@ import (
 	"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"
 	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 )
 
 // DefaultRetries states the default number of times the service client will
@@ -56,10 +58,12 @@ type Client struct {
 // with the defaults package and credentials EC2 Role Provider.
 func New(config *Config) *Client {
 	service := &service.Service{
-		Config:      copyConfig(config),
+		ServiceInfo: serviceinfo.ServiceInfo{
-		ServiceName: "Client",
+			Config:      copyConfig(config),
-		Endpoint:    "http://169.254.169.254/latest",
+			ServiceName: "Client",
-		APIVersion:  "latest",
+			Endpoint:    "http://169.254.169.254/latest",
+			APIVersion:  "latest",
+		},
 	}
 	service.Initialize()
 	service.Handlers.Unmarshal.PushBack(unmarshalHandler)
@@ -103,7 +107,7 @@ type metadataOutput struct {
 	Content string
 }
 
-func unmarshalHandler(r *service.Request) {
+func unmarshalHandler(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 	b, err := ioutil.ReadAll(r.HTTPResponse.Body)
 	if err != nil {
@@ -114,7 +118,7 @@ func unmarshalHandler(r *service.Request) {
 	data.Content = string(b)
 }
 
-func unmarshalError(r *service.Request) {
+func unmarshalError(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 	_, err := ioutil.ReadAll(r.HTTPResponse.Body)
 	if err != nil {
@@ -124,8 +128,8 @@ func unmarshalError(r *service.Request) {
 	// TODO extract the error...
 }
 
-func validateEndpointHandler(r *service.Request) {
+func validateEndpointHandler(r *request.Request) {
 	if r.Service.Endpoint == "" {
-		r.Error = service.ErrMissingEndpoint
+		r.Error = aws.ErrMissingEndpoint
 	}
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/errors.go

@@ -0,0 +1,17 @@
+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.
+	//
+	// @readonly
+	ErrMissingRegion error = 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.
+	//
+	// @readonly
+	ErrMissingEndpoint error = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil)
+)

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/handlers.go

@@ -1,4 +1,4 @@
-package service
+package request
 
 // A Handlers provides a collection of request handlers for various
 // stages of handling requests.
@@ -15,8 +15,8 @@ type Handlers struct {
 	AfterRetry       HandlerList
 }
 
-// copy returns of this handler's lists.
+// Copy returns of this handler's lists.
-func (h *Handlers) copy() Handlers {
+func (h *Handlers) Copy() Handlers {
 	return Handlers{
 		Validate:         h.Validate.copy(),
 		Build:            h.Build.copy(),
@@ -47,19 +47,25 @@ func (h *Handlers) Clear() {
 
 // A HandlerList manages zero or more handlers in a list.
 type HandlerList struct {
-	list []func(*Request)
+	list []NamedHandler
+}
+
+// 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 {
 	var n HandlerList
-	n.list = append([]func(*Request){}, l.list...)
+	n.list = append([]NamedHandler{}, l.list...)
 	return n
 }
 
 // Clear clears the handler list.
 func (l *HandlerList) Clear() {
-	l.list = []func(*Request){}
+	l.list = []NamedHandler{}
 }
 
 // Len returns the number of handlers in the list.
@@ -67,19 +73,40 @@ func (l *HandlerList) Len() int {
 	return len(l.list)
 }
 
-// PushBack pushes handlers f to the back of the handler list.
+// PushBack pushes handler f to the back of the handler list.
-func (l *HandlerList) PushBack(f ...func(*Request)) {
+func (l *HandlerList) PushBack(f func(*Request)) {
-	l.list = append(l.list, f...)
+	l.list = append(l.list, NamedHandler{"__anonymous", f})
 }
 
-// PushFront pushes handlers f to the front of the handler list.
+// PushFront pushes handler f to the front of the handler list.
-func (l *HandlerList) PushFront(f ...func(*Request)) {
+func (l *HandlerList) PushFront(f func(*Request)) {
-	l.list = append(f, l.list...)
+	l.list = append([]NamedHandler{{"__anonymous", f}}, l.list...)
+}
+
+// PushBackNamed pushes named handler f to the back of the handler list.
+func (l *HandlerList) PushBackNamed(n NamedHandler) {
+	l.list = append(l.list, n)
+}
+
+// PushFrontNamed pushes named handler f to the front of the handler list.
+func (l *HandlerList) PushFrontNamed(n NamedHandler) {
+	l.list = append([]NamedHandler{n}, l.list...)
+}
+
+// Remove removes a NamedHandler n
+func (l *HandlerList) Remove(n NamedHandler) {
+	newlist := []NamedHandler{}
+	for _, m := range l.list {
+		if m.Name != n.Name {
+			newlist = append(newlist, m)
+		}
+	}
+	l.list = newlist
 }
 
 // Run executes all handlers in the list with a given request object.
 func (l *HandlerList) Run(r *Request) {
 	for _, f := range l.list {
-		f(r)
+		f.Fn(r)
 	}
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/request.go

@@ -1,4 +1,4 @@
-package service
+package request
 
 import (
 	"bytes"
@@ -13,11 +13,13 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awsutil"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 )
 
 // A Request is the service request to be made.
 type Request struct {
-	*Service
+	Retryer
+	Service      serviceinfo.ServiceInfo
 	Handlers     Handlers
 	Time         time.Time
 	ExpireTime   time.Duration
@@ -25,7 +27,7 @@ type Request struct {
 	HTTPRequest  *http.Request
 	HTTPResponse *http.Response
 	Body         io.ReadSeeker
-	bodyStart    int64 // offset from beginning of Body that the request body starts
+	BodyStart    int64 // offset from beginning of Body that the request body starts
 	Params       interface{}
 	Error        error
 	Data         interface{}
@@ -53,13 +55,13 @@ type Paginator struct {
 	TruncationToken string
 }
 
-// NewRequest returns a new Request pointer for the service API
+// 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 NewRequest(service *Service, operation *Operation, params interface{}, data interface{}) *Request {
+func New(service serviceinfo.ServiceInfo, handlers Handlers, retryer Retryer, operation *Operation, params interface{}, data interface{}) *Request {
 	method := operation.HTTPMethod
 	if method == "" {
 		method = "POST"
@@ -73,8 +75,9 @@ func NewRequest(service *Service, operation *Operation, params interface{}, data
 	httpReq.URL, _ = url.Parse(service.Endpoint + p)
 
 	r := &Request{
+		Retryer:     retryer,
 		Service:     service,
-		Handlers:    service.Handlers.copy(),
+		Handlers:    handlers.Copy(),
 		Time:        time.Now(),
 		ExpireTime:  0,
 		Operation:   operation,
@@ -91,7 +94,7 @@ func NewRequest(service *Service, operation *Operation, params interface{}, data
 
 // WillRetry returns if the request's can be retried.
 func (r *Request) WillRetry() bool {
-	return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.Service.MaxRetries()
+	return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.MaxRetries()
 }
 
 // ParamsFilled returns if the request's parameters have been populated
@@ -137,7 +140,7 @@ func (r *Request) Presign(expireTime time.Duration) (string, error) {
 }
 
 func debugLogReqError(r *Request, stage string, retrying bool, err error) {
-	if !r.Config.LogLevel.Matches(aws.LogDebugWithRequestErrors) {
+	if !r.Service.Config.LogLevel.Matches(aws.LogDebugWithRequestErrors) {
 		return
 	}
 
@@ -146,8 +149,8 @@ func debugLogReqError(r *Request, stage string, retrying bool, err error) {
 		retryStr = "will retry"
 	}
 
-	r.Config.Logger.Log(fmt.Sprintf("DEBUG: %s %s/%s failed, %s, error %v",
+	r.Service.Config.Logger.Log(fmt.Sprintf("DEBUG: %s %s/%s failed, %s, error %v",
-		stage, r.ServiceName, r.Operation.Name, retryStr, err))
+		stage, r.Service.ServiceName, r.Operation.Name, retryStr, err))
 }
 
 // Build will build the request's object so it can be signed and sent
@@ -202,14 +205,14 @@ func (r *Request) Send() error {
 		}
 
 		if aws.BoolValue(r.Retryable) {
-			if r.Config.LogLevel.Matches(aws.LogDebugWithRequestRetries) {
+			if r.Service.Config.LogLevel.Matches(aws.LogDebugWithRequestRetries) {
-				r.Config.Logger.Log(fmt.Sprintf("DEBUG: Retrying Request %s/%s, attempt %d",
+				r.Service.Config.Logger.Log(fmt.Sprintf("DEBUG: Retrying Request %s/%s, attempt %d",
-					r.ServiceName, r.Operation.Name, r.RetryCount))
+					r.Service.ServiceName, r.Operation.Name, r.RetryCount))
 			}
 
 			// Re-seek the body back to the original point in for a retry so that
 			// send will send the body's contents again in the upcoming request.
-			r.Body.Seek(r.bodyStart, 0)
+			r.Body.Seek(r.BodyStart, 0)
 			r.HTTPRequest.Body = ioutil.NopCloser(r.Body)
 		}
 		r.Retryable = nil
@@ -312,7 +315,7 @@ func (r *Request) NextPage() *Request {
 	}
 
 	data := reflect.New(reflect.TypeOf(r.Data).Elem()).Interface()
-	nr := NewRequest(r.Service, r.Operation, awsutil.CopyOf(r.Params), data)
+	nr := New(r.Service, r.Handlers, r.Retryer, r.Operation, awsutil.CopyOf(r.Params), data)
 	for i, intok := range nr.Operation.InputTokens {
 		awsutil.SetValueAtAnyPath(nr.Params, intok, tokens[i])
 	}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request/retryer.go

@@ -0,0 +1,71 @@
+package request
+
+import (
+	"time"
+
+	"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 service.DefaultRetryer
+// structure, which contains basic retry logic using exponential backoff.
+type Retryer interface {
+	RetryRules(*Request) time.Duration
+	ShouldRetry(*Request) bool
+	MaxRetries() uint
+}
+
+// retryableCodes is a collection of service response codes which are retry-able
+// without any further action.
+var retryableCodes = map[string]struct{}{
+	"RequestError":                           {},
+	"ProvisionedThroughputExceededException": {},
+	"Throttling":                             {},
+	"ThrottlingException":                    {},
+	"RequestLimitExceeded":                   {},
+	"RequestThrottled":                       {},
+}
+
+// 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 isCodeRetryable(code string) bool {
+	if _, ok := retryableCodes[code]; ok {
+		return true
+	}
+
+	return isCodeExpiredCreds(code)
+}
+
+func isCodeExpiredCreds(code string) bool {
+	_, ok := credsExpiredCodes[code]
+	return ok
+}
+
+// IsErrorRetryable returns whether the error is retryable, based on its Code.
+// Returns false if the request has no Error set.
+func (r *Request) IsErrorRetryable() bool {
+	if r.Error != nil {
+		if err, ok := r.Error.(awserr.Error); ok {
+			return isCodeRetryable(err.Code())
+		}
+	}
+	return false
+}
+
+// IsErrorExpired returns whether the error code is a credential expiry error.
+// Returns false if the request has no Error set.
+func (r *Request) IsErrorExpired() bool {
+	if r.Error != nil {
+		if err, ok := r.Error.(awserr.Error); ok {
+			return isCodeExpiredCreds(err.Code())
+		}
+	}
+	return false
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/default_retryer.go

@@ -0,0 +1,51 @@
+package service
+
+import (
+	"math"
+	"math/rand"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+// 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 {
+//      service.DefaultRetryer
+//    }
+//
+//    // This implementation always has 100 max retries
+//    func (d retryer) MaxRetries() uint { return 100 }
+type DefaultRetryer struct {
+	*Service
+}
+
+// MaxRetries returns the number of maximum returns the service will use to make
+// an individual API request.
+func (d DefaultRetryer) MaxRetries() uint {
+	if aws.IntValue(d.Service.Config.MaxRetries) < 0 {
+		return d.DefaultMaxRetries
+	}
+	return uint(aws.IntValue(d.Service.Config.MaxRetries))
+}
+
+var seededRand = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// RetryRules returns the delay duration before retrying this request again
+func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {
+	delay := int(math.Pow(2, float64(r.RetryCount))) * (seededRand.Intn(30) + 30)
+	return time.Duration(delay) * time.Millisecond
+}
+
+// ShouldRetry returns if the request should be retried.
+func (d DefaultRetryer) ShouldRetry(r *request.Request) bool {
+	if r.HTTPResponse.StatusCode >= 500 {
+		return true
+	}
+	return r.IsErrorRetryable()
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/handler_functions_test.go

@@ -1,106 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"net/http"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-)
-
-func TestValidateEndpointHandler(t *testing.T) {
-	os.Clearenv()
-	svc := NewService(aws.NewConfig().WithRegion("us-west-2"))
-	svc.Handlers.Clear()
-	svc.Handlers.Validate.PushBack(ValidateEndpointHandler)
-
-	req := NewRequest(svc, &Operation{Name: "Operation"}, nil, nil)
-	err := req.Build()
-
-	assert.NoError(t, err)
-}
-
-func TestValidateEndpointHandlerErrorRegion(t *testing.T) {
-	os.Clearenv()
-	svc := NewService(nil)
-	svc.Handlers.Clear()
-	svc.Handlers.Validate.PushBack(ValidateEndpointHandler)
-
-	req := NewRequest(svc, &Operation{Name: "Operation"}, nil, nil)
-	err := req.Build()
-
-	assert.Error(t, err)
-	assert.Equal(t, ErrMissingRegion, err)
-}
-
-type mockCredsProvider struct {
-	expired        bool
-	retrieveCalled bool
-}
-
-func (m *mockCredsProvider) Retrieve() (credentials.Value, error) {
-	m.retrieveCalled = true
-	return credentials.Value{}, nil
-}
-
-func (m *mockCredsProvider) IsExpired() bool {
-	return m.expired
-}
-
-func TestAfterRetryRefreshCreds(t *testing.T) {
-	os.Clearenv()
-	credProvider := &mockCredsProvider{}
-	svc := NewService(&aws.Config{Credentials: credentials.NewCredentials(credProvider), MaxRetries: aws.Int(1)})
-
-	svc.Handlers.Clear()
-	svc.Handlers.ValidateResponse.PushBack(func(r *Request) {
-		r.Error = awserr.New("UnknownError", "", nil)
-		r.HTTPResponse = &http.Response{StatusCode: 400}
-	})
-	svc.Handlers.UnmarshalError.PushBack(func(r *Request) {
-		r.Error = awserr.New("ExpiredTokenException", "", nil)
-	})
-	svc.Handlers.AfterRetry.PushBack(func(r *Request) {
-		AfterRetryHandler(r)
-	})
-
-	assert.True(t, svc.Config.Credentials.IsExpired(), "Expect to start out expired")
-	assert.False(t, credProvider.retrieveCalled)
-
-	req := NewRequest(svc, &Operation{Name: "Operation"}, nil, nil)
-	req.Send()
-
-	assert.True(t, svc.Config.Credentials.IsExpired())
-	assert.False(t, credProvider.retrieveCalled)
-
-	_, err := svc.Config.Credentials.Get()
-	assert.NoError(t, err)
-	assert.True(t, credProvider.retrieveCalled)
-}
-
-type testSendHandlerTransport struct{}
-
-func (t *testSendHandlerTransport) RoundTrip(r *http.Request) (*http.Response, error) {
-	return nil, fmt.Errorf("mock error")
-}
-
-func TestSendHandlerError(t *testing.T) {
-	svc := NewService(&aws.Config{
-		HTTPClient: &http.Client{
-			Transport: &testSendHandlerTransport{},
-		},
-	})
-	svc.Handlers.Clear()
-	svc.Handlers.Send.PushBack(SendHandler)
-	r := NewRequest(svc, &Operation{Name: "Operation"}, nil, nil)
-
-	r.Send()
-
-	assert.Error(t, r.Error)
-	assert.NotNil(t, r.HTTPResponse)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/handlers_test.go

@@ -1,33 +0,0 @@
-package service
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-)
-
-func TestHandlerList(t *testing.T) {
-	s := ""
-	r := &Request{}
-	l := HandlerList{}
-	l.PushBack(func(r *Request) {
-		s += "a"
-		r.Data = s
-	})
-	l.Run(r)
-	assert.Equal(t, "a", s)
-	assert.Equal(t, "a", r.Data)
-}
-
-func TestMultipleHandlers(t *testing.T) {
-	r := &Request{}
-	l := HandlerList{}
-	l.PushBack(func(r *Request) { r.Data = nil })
-	l.PushFront(func(r *Request) { r.Data = aws.Bool(true) })
-	l.Run(r)
-	if r.Data != nil {
-		t.Error("Expected handler to execute")
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/param_validator.go

@@ -1,89 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// ValidateParameters is a request handler to validate the input parameters.
-// Validating parameters only has meaning if done prior to the request being sent.
-func ValidateParameters(r *Request) {
-	if r.ParamsFilled() {
-		v := validator{errors: []string{}}
-		v.validateAny(reflect.ValueOf(r.Params), "")
-
-		if count := len(v.errors); count > 0 {
-			format := "%d validation errors:\n- %s"
-			msg := fmt.Sprintf(format, count, strings.Join(v.errors, "\n- "))
-			r.Error = awserr.New("InvalidParameter", msg, nil)
-		}
-	}
-}
-
-// A validator validates values. Collects validations errors which occurs.
-type validator struct {
-	errors []string
-}
-
-// validateAny will validate any struct, slice or map type. All validations
-// are also performed recursively for nested types.
-func (v *validator) validateAny(value reflect.Value, path string) {
-	value = reflect.Indirect(value)
-	if !value.IsValid() {
-		return
-	}
-
-	switch value.Kind() {
-	case reflect.Struct:
-		v.validateStruct(value, path)
-	case reflect.Slice:
-		for i := 0; i < value.Len(); i++ {
-			v.validateAny(value.Index(i), path+fmt.Sprintf("[%d]", i))
-		}
-	case reflect.Map:
-		for _, n := range value.MapKeys() {
-			v.validateAny(value.MapIndex(n), path+fmt.Sprintf("[%q]", n.String()))
-		}
-	}
-}
-
-// validateStruct will validate the struct value's fields. If the structure has
-// nested types those types will be validated also.
-func (v *validator) validateStruct(value reflect.Value, path string) {
-	prefix := "."
-	if path == "" {
-		prefix = ""
-	}
-
-	for i := 0; i < value.Type().NumField(); i++ {
-		f := value.Type().Field(i)
-		if strings.ToLower(f.Name[0:1]) == f.Name[0:1] {
-			continue
-		}
-		fvalue := value.FieldByName(f.Name)
-
-		notset := false
-		if f.Tag.Get("required") != "" {
-			switch fvalue.Kind() {
-			case reflect.Ptr, reflect.Slice, reflect.Map:
-				if fvalue.IsNil() {
-					notset = true
-				}
-			default:
-				if !fvalue.IsValid() {
-					notset = true
-				}
-			}
-		}
-
-		if notset {
-			msg := "missing required parameter: " + path + prefix + f.Name
-			v.errors = append(v.errors, msg)
-		} else {
-			v.validateAny(fvalue, path+prefix+f.Name)
-		}
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/param_validator_test.go

@@ -1,85 +0,0 @@
-package service
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-var testSvc = func() *Service {
-	s := &Service{
-		Config:      &aws.Config{},
-		ServiceName: "mock-service",
-		APIVersion:  "2015-01-01",
-	}
-	return s
-}()
-
-type StructShape struct {
-	RequiredList   []*ConditionalStructShape          `required:"true"`
-	RequiredMap    map[string]*ConditionalStructShape `required:"true"`
-	RequiredBool   *bool                              `required:"true"`
-	OptionalStruct *ConditionalStructShape
-
-	hiddenParameter *string
-
-	metadataStructureShape
-}
-
-type metadataStructureShape struct {
-	SDKShapeTraits bool
-}
-
-type ConditionalStructShape struct {
-	Name           *string `required:"true"`
-	SDKShapeTraits bool
-}
-
-func TestNoErrors(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {Name: aws.String("Name")},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")},
-	}
-
-	req := NewRequest(testSvc, &Operation{}, input, nil)
-	ValidateParameters(req)
-	assert.NoError(t, req.Error)
-}
-
-func TestMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{}
-	req := NewRequest(testSvc, &Operation{}, input, nil)
-	ValidateParameters(req)
-
-	assert.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList\n- missing required parameter: RequiredMap\n- missing required parameter: RequiredBool", req.Error.(awserr.Error).Message())
-}
-
-func TestNestedMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{{}},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{},
-	}
-
-	req := NewRequest(testSvc, &Operation{}, input, nil)
-	ValidateParameters(req)
-
-	assert.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList[0].Name\n- missing required parameter: RequiredMap[\"key2\"].Name\n- missing required parameter: OptionalStruct.Name", req.Error.(awserr.Error).Message())
-
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/request_pagination_test.go

@@ -1,307 +0,0 @@
-package service_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/dynamodb"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-var _ = unit.Imported
-
-// Use DynamoDB methods for simplicity
-func TestPagination(t *testing.T) {
-	db := dynamodb.New(nil)
-	tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Build.PushBack(func(r *service.Request) {
-		in := r.Params.(*dynamodb.ListTablesInput)
-		if in == nil {
-			tokens = append(tokens, "")
-		} else if in.ExclusiveStartTableName != nil {
-			tokens = append(tokens, *in.ExclusiveStartTableName)
-		}
-	})
-	db.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	err := db.ListTablesPages(params, func(p *dynamodb.ListTablesOutput, last bool) bool {
-		numPages++
-		for _, t := range p.TableNames {
-			pages = append(pages, *t)
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-		return true
-	})
-
-	assert.Equal(t, []string{"Table2", "Table4"}, tokens)
-	assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages)
-	assert.Equal(t, 3, numPages)
-	assert.True(t, gotToEnd)
-	assert.Nil(t, err)
-	assert.Nil(t, params.ExclusiveStartTableName)
-}
-
-// Use DynamoDB methods for simplicity
-func TestPaginationEachPage(t *testing.T) {
-	db := dynamodb.New(nil)
-	tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Build.PushBack(func(r *service.Request) {
-		in := r.Params.(*dynamodb.ListTablesInput)
-		if in == nil {
-			tokens = append(tokens, "")
-		} else if in.ExclusiveStartTableName != nil {
-			tokens = append(tokens, *in.ExclusiveStartTableName)
-		}
-	})
-	db.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	req, _ := db.ListTablesRequest(params)
-	err := req.EachPage(func(p interface{}, last bool) bool {
-		numPages++
-		for _, t := range p.(*dynamodb.ListTablesOutput).TableNames {
-			pages = append(pages, *t)
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-
-		return true
-	})
-
-	assert.Equal(t, []string{"Table2", "Table4"}, tokens)
-	assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages)
-	assert.Equal(t, 3, numPages)
-	assert.True(t, gotToEnd)
-	assert.Nil(t, err)
-}
-
-// Use DynamoDB methods for simplicity
-func TestPaginationEarlyExit(t *testing.T) {
-	db := dynamodb.New(nil)
-	numPages, gotToEnd := 0, false
-
-	reqNum := 0
-	resps := []*dynamodb.ListTablesOutput{
-		{TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")},
-		{TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")},
-		{TableNames: []*string{aws.String("Table5")}},
-	}
-
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	db.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = resps[reqNum]
-		reqNum++
-	})
-
-	params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	err := db.ListTablesPages(params, func(p *dynamodb.ListTablesOutput, last bool) bool {
-		numPages++
-		if numPages == 2 {
-			return false
-		}
-		if last {
-			if gotToEnd {
-				assert.Fail(t, "last=true happened twice")
-			}
-			gotToEnd = true
-		}
-		return true
-	})
-
-	assert.Equal(t, 2, numPages)
-	assert.False(t, gotToEnd)
-	assert.Nil(t, err)
-}
-
-func TestSkipPagination(t *testing.T) {
-	client := s3.New(nil)
-	client.Handlers.Send.Clear() // mock sending
-	client.Handlers.Unmarshal.Clear()
-	client.Handlers.UnmarshalMeta.Clear()
-	client.Handlers.ValidateResponse.Clear()
-	client.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = &s3.HeadBucketOutput{}
-	})
-
-	req, _ := client.HeadBucketRequest(&s3.HeadBucketInput{Bucket: aws.String("bucket")})
-
-	numPages, gotToEnd := 0, false
-	req.EachPage(func(p interface{}, last bool) bool {
-		numPages++
-		if last {
-			gotToEnd = true
-		}
-		return true
-	})
-	assert.Equal(t, 1, numPages)
-	assert.True(t, gotToEnd)
-}
-
-// Use S3 for simplicity
-func TestPaginationTruncation(t *testing.T) {
-	count := 0
-	client := s3.New(nil)
-
-	reqNum := &count
-	resps := []*s3.ListObjectsOutput{
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key1")}}},
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key2")}}},
-		{IsTruncated: aws.Bool(false), Contents: []*s3.Object{{Key: aws.String("Key3")}}},
-		{IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key4")}}},
-	}
-
-	client.Handlers.Send.Clear() // mock sending
-	client.Handlers.Unmarshal.Clear()
-	client.Handlers.UnmarshalMeta.Clear()
-	client.Handlers.ValidateResponse.Clear()
-	client.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = resps[*reqNum]
-		*reqNum++
-	})
-
-	params := &s3.ListObjectsInput{Bucket: aws.String("bucket")}
-
-	results := []string{}
-	err := client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool {
-		results = append(results, *p.Contents[0].Key)
-		return true
-	})
-
-	assert.Equal(t, []string{"Key1", "Key2", "Key3"}, results)
-	assert.Nil(t, err)
-
-	// Try again without truncation token at all
-	count = 0
-	resps[1].IsTruncated = nil
-	resps[2].IsTruncated = aws.Bool(true)
-	results = []string{}
-	err = client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool {
-		results = append(results, *p.Contents[0].Key)
-		return true
-	})
-
-	assert.Equal(t, []string{"Key1", "Key2"}, results)
-	assert.Nil(t, err)
-
-}
-
-// Benchmarks
-var benchResps = []*dynamodb.ListTablesOutput{
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE"), aws.String("NXT")}, LastEvaluatedTableName: aws.String("NXT")},
-	{TableNames: []*string{aws.String("TABLE")}},
-}
-
-var benchDb = func() *dynamodb.DynamoDB {
-	db := dynamodb.New(nil)
-	db.Handlers.Send.Clear() // mock sending
-	db.Handlers.Unmarshal.Clear()
-	db.Handlers.UnmarshalMeta.Clear()
-	db.Handlers.ValidateResponse.Clear()
-	return db
-}
-
-func BenchmarkCodegenIterator(b *testing.B) {
-	reqNum := 0
-	db := benchDb()
-	db.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = benchResps[reqNum]
-		reqNum++
-	})
-
-	input := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	iter := func(fn func(*dynamodb.ListTablesOutput, bool) bool) error {
-		page, _ := db.ListTablesRequest(input)
-		for ; page != nil; page = page.NextPage() {
-			page.Send()
-			out := page.Data.(*dynamodb.ListTablesOutput)
-			if result := fn(out, !page.HasNextPage()); page.Error != nil || !result {
-				return page.Error
-			}
-		}
-		return nil
-	}
-
-	for i := 0; i < b.N; i++ {
-		reqNum = 0
-		iter(func(p *dynamodb.ListTablesOutput, last bool) bool {
-			return true
-		})
-	}
-}
-
-func BenchmarkEachPageIterator(b *testing.B) {
-	reqNum := 0
-	db := benchDb()
-	db.Handlers.Unmarshal.PushBack(func(r *service.Request) {
-		r.Data = benchResps[reqNum]
-		reqNum++
-	})
-
-	input := &dynamodb.ListTablesInput{Limit: aws.Int64(2)}
-	for i := 0; i < b.N; i++ {
-		reqNum = 0
-		req, _ := db.ListTablesRequest(input)
-		req.EachPage(func(p interface{}, last bool) bool {
-			return true
-		})
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/request_test.go

@@ -1,226 +0,0 @@
-package service
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"testing"
-	"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/stretchr/testify/assert"
-)
-
-type testData struct {
-	Data string
-}
-
-func body(str string) io.ReadCloser {
-	return ioutil.NopCloser(bytes.NewReader([]byte(str)))
-}
-
-func unmarshal(req *Request) {
-	defer req.HTTPResponse.Body.Close()
-	if req.Data != nil {
-		json.NewDecoder(req.HTTPResponse.Body).Decode(req.Data)
-	}
-	return
-}
-
-func unmarshalError(req *Request) {
-	bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body)
-	if err != nil {
-		req.Error = awserr.New("UnmarshaleError", req.HTTPResponse.Status, err)
-		return
-	}
-	if len(bodyBytes) == 0 {
-		req.Error = awserr.NewRequestFailure(
-			awserr.New("UnmarshaleError", req.HTTPResponse.Status, fmt.Errorf("empty body")),
-			req.HTTPResponse.StatusCode,
-			"",
-		)
-		return
-	}
-	var jsonErr jsonErrorResponse
-	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
-		req.Error = awserr.New("UnmarshaleError", "JSON unmarshal", err)
-		return
-	}
-	req.Error = awserr.NewRequestFailure(
-		awserr.New(jsonErr.Code, jsonErr.Message, nil),
-		req.HTTPResponse.StatusCode,
-		"",
-	)
-}
-
-type jsonErrorResponse struct {
-	Code    string `json:"__type"`
-	Message string `json:"message"`
-}
-
-// test that retries occur for 5xx status codes
-func TestRequestRecoverRetry5xx(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 501, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := NewService(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := NewRequest(s, &Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-	assert.Equal(t, 2, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}
-
-// test that retries occur for 4xx status codes with a response type that can be retried - see `shouldRetry`
-func TestRequestRecoverRetry4xxRetryable(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 400, Body: body(`{"__type":"Throttling","message":"Rate exceeded."}`)},
-		{StatusCode: 429, Body: body(`{"__type":"ProvisionedThroughputExceededException","message":"Rate exceeded."}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := NewService(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := NewRequest(s, &Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-	assert.Equal(t, 2, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}
-
-// test that retries don't occur for 4xx status codes with a response type that can't be retried
-func TestRequest4xxUnretryable(t *testing.T) {
-	s := NewService(aws.NewConfig().WithMaxRetries(10))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *Request) {
-		r.HTTPResponse = &http.Response{StatusCode: 401, Body: body(`{"__type":"SignatureDoesNotMatch","message":"Signature does not match."}`)}
-	})
-	out := &testData{}
-	r := NewRequest(s, &Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.NotNil(t, err)
-	if e, ok := err.(awserr.RequestFailure); ok {
-		assert.Equal(t, 401, e.StatusCode())
-	} else {
-		assert.Fail(t, "Expected error to be a service failure")
-	}
-	assert.Equal(t, "SignatureDoesNotMatch", err.(awserr.Error).Code())
-	assert.Equal(t, "Signature does not match.", err.(awserr.Error).Message())
-	assert.Equal(t, 0, int(r.RetryCount))
-}
-
-func TestRequestExhaustRetries(t *testing.T) {
-	delays := []time.Duration{}
-	sleepDelay = func(delay time.Duration) {
-		delays = append(delays, delay)
-	}
-
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-		{StatusCode: 500, Body: body(`{"__type":"UnknownError","message":"An error occurred."}`)},
-	}
-
-	s := NewService(aws.NewConfig().WithMaxRetries(aws.DefaultRetries))
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	r := NewRequest(s, &Operation{Name: "Operation"}, nil, nil)
-	err := r.Send()
-	assert.NotNil(t, err)
-	if e, ok := err.(awserr.RequestFailure); ok {
-		assert.Equal(t, 500, e.StatusCode())
-	} else {
-		assert.Fail(t, "Expected error to be a service failure")
-	}
-	assert.Equal(t, "UnknownError", err.(awserr.Error).Code())
-	assert.Equal(t, "An error occurred.", err.(awserr.Error).Message())
-	assert.Equal(t, 3, int(r.RetryCount))
-
-	expectDelays := []struct{ min, max time.Duration }{{30, 59}, {60, 118}, {120, 236}}
-	for i, v := range delays {
-		min := expectDelays[i].min * time.Millisecond
-		max := expectDelays[i].max * time.Millisecond
-		assert.True(t, min <= v && v <= max,
-			"Expect delay to be within range, i:%d, v:%s, min:%s, max:%s", i, v, min, max)
-	}
-}
-
-// test that the request is retried after the credentials are expired.
-func TestRequestRecoverExpiredCreds(t *testing.T) {
-	reqNum := 0
-	reqs := []http.Response{
-		{StatusCode: 400, Body: body(`{"__type":"ExpiredTokenException","message":"expired token"}`)},
-		{StatusCode: 200, Body: body(`{"data":"valid"}`)},
-	}
-
-	s := NewService(&aws.Config{MaxRetries: aws.Int(10), Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "")})
-	s.Handlers.Validate.Clear()
-	s.Handlers.Unmarshal.PushBack(unmarshal)
-	s.Handlers.UnmarshalError.PushBack(unmarshalError)
-
-	credExpiredBeforeRetry := false
-	credExpiredAfterRetry := false
-
-	s.Handlers.AfterRetry.PushBack(func(r *Request) {
-		credExpiredAfterRetry = r.Config.Credentials.IsExpired()
-	})
-
-	s.Handlers.Sign.Clear()
-	s.Handlers.Sign.PushBack(func(r *Request) {
-		r.Config.Credentials.Get()
-	})
-	s.Handlers.Send.Clear() // mock sending
-	s.Handlers.Send.PushBack(func(r *Request) {
-		r.HTTPResponse = &reqs[reqNum]
-		reqNum++
-	})
-	out := &testData{}
-	r := NewRequest(s, &Operation{Name: "Operation"}, nil, out)
-	err := r.Send()
-	assert.Nil(t, err)
-
-	assert.False(t, credExpiredBeforeRetry, "Expect valid creds before retry check")
-	assert.True(t, credExpiredAfterRetry, "Expect expired creds after retry check")
-	assert.False(t, s.Config.Credentials.IsExpired(), "Expect valid creds after cred expired recovery")
-
-	assert.Equal(t, 1, int(r.RetryCount))
-	assert.Equal(t, "valid", out.Data)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/service.go

@@ -3,40 +3,32 @@ package service
 import (
 	"fmt"
 	"io/ioutil"
-	"math"
-	"math/rand"
 	"net/http"
 	"net/http/httputil"
 	"regexp"
 	"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/request"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 	"github.com/aws/aws-sdk-go/internal/endpoints"
 )
 
 // A Service implements the base service request and response handling
 // used by all services.
 type Service struct {
-	Config            *aws.Config
+	serviceinfo.ServiceInfo
-	Handlers          Handlers
+	request.Retryer
-	ServiceName       string
-	APIVersion        string
-	Endpoint          string
-	SigningName       string
-	SigningRegion     string
-	JSONVersion       string
-	TargetPrefix      string
-	RetryRules        func(*Request) time.Duration
-	ShouldRetry       func(*Request) bool
 	DefaultMaxRetries uint
+	Handlers          request.Handlers
 }
 
 var schemeRE = regexp.MustCompile("^([^:]+)://")
 
-// NewService will return a pointer to a new Server object initialized.
+// New will return a pointer to a new Server object initialized.
-func NewService(config *aws.Config) *Service {
+func New(config *aws.Config) *Service {
-	svc := &Service{Config: config}
+	svc := &Service{ServiceInfo: serviceinfo.ServiceInfo{Config: config}}
 	svc.Initialize()
 	return svc
 }
@@ -49,28 +41,29 @@ func (s *Service) Initialize() {
 	if s.Config.HTTPClient == nil {
 		s.Config.HTTPClient = http.DefaultClient
 	}
-
+	if s.Config.SleepDelay == nil {
-	if s.RetryRules == nil {
+		s.Config.SleepDelay = time.Sleep
-		s.RetryRules = retryRules
-	}
-
-	if s.ShouldRetry == nil {
-		s.ShouldRetry = shouldRetry
 	}
 
+	s.Retryer = DefaultRetryer{s}
 	s.DefaultMaxRetries = 3
-	s.Handlers.Validate.PushBack(ValidateEndpointHandler)
+	s.Handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
-	s.Handlers.Build.PushBack(UserAgentHandler)
+	s.Handlers.Build.PushBackNamed(corehandlers.UserAgentHandler)
-	s.Handlers.Sign.PushBack(BuildContentLength)
+	s.Handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)
-	s.Handlers.Send.PushBack(SendHandler)
+	s.Handlers.Send.PushBackNamed(corehandlers.SendHandler)
-	s.Handlers.AfterRetry.PushBack(AfterRetryHandler)
+	s.Handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
-	s.Handlers.ValidateResponse.PushBack(ValidateResponseHandler)
+	s.Handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)
+	if !aws.BoolValue(s.Config.DisableParamValidation) {
+		s.Handlers.Validate.PushBackNamed(corehandlers.ValidateParametersHandler)
+	}
 	s.AddDebugHandlers()
 	s.buildEndpoint()
+}
 
-	if !aws.BoolValue(s.Config.DisableParamValidation) {
+// NewRequest returns a new Request pointer for the service API
-		s.Handlers.Validate.PushBack(ValidateParameters)
+// operation and parameters.
-	}
+func (s *Service) NewRequest(operation *request.Operation, params interface{}, data interface{}) *request.Request {
+	return request.New(s.ServiceInfo, s.Handlers, s.Retryer, operation, params, data)
 }
 
 // buildEndpoint builds the endpoint values the service will use to make requests with.
@@ -107,19 +100,19 @@ const logReqMsg = `DEBUG: Request %s/%s Details:
 %s
 -----------------------------------------------------`
 
-func logRequest(r *Request) {
+func logRequest(r *request.Request) {
-	logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
+	logBody := r.Service.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
 	dumpedBody, _ := httputil.DumpRequestOut(r.HTTPRequest, logBody)
 
 	if logBody {
 		// 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.Body.Seek(r.bodyStart, 0)
+		r.Body.Seek(r.BodyStart, 0)
 		r.HTTPRequest.Body = ioutil.NopCloser(r.Body)
 	}
 
-	r.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.ServiceName, r.Operation.Name, string(dumpedBody)))
+	r.Service.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.Service.ServiceName, r.Operation.Name, string(dumpedBody)))
 }
 
 const logRespMsg = `DEBUG: Response %s/%s Details:
@@ -127,78 +120,14 @@ const logRespMsg = `DEBUG: Response %s/%s Details:
 %s
 -----------------------------------------------------`
 
-func logResponse(r *Request) {
+func logResponse(r *request.Request) {
 	var msg = "no reponse data"
 	if r.HTTPResponse != nil {
-		logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
+		logBody := r.Service.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
 		dumpedBody, _ := httputil.DumpResponse(r.HTTPResponse, logBody)
 		msg = string(dumpedBody)
 	} else if r.Error != nil {
 		msg = r.Error.Error()
 	}
-	r.Config.Logger.Log(fmt.Sprintf(logRespMsg, r.ServiceName, r.Operation.Name, msg))
+	r.Service.Config.Logger.Log(fmt.Sprintf(logRespMsg, r.Service.ServiceName, r.Operation.Name, msg))
-}
-
-// MaxRetries returns the number of maximum returns the service will use to make
-// an individual API request.
-func (s *Service) MaxRetries() uint {
-	if aws.IntValue(s.Config.MaxRetries) < 0 {
-		return s.DefaultMaxRetries
-	}
-	return uint(aws.IntValue(s.Config.MaxRetries))
-}
-
-var seededRand = rand.New(rand.NewSource(time.Now().UnixNano()))
-
-// retryRules returns the delay duration before retrying this request again
-func retryRules(r *Request) time.Duration {
-
-	delay := int(math.Pow(2, float64(r.RetryCount))) * (seededRand.Intn(30) + 30)
-	return time.Duration(delay) * time.Millisecond
-}
-
-// retryableCodes is a collection of service response codes which are retry-able
-// without any further action.
-var retryableCodes = map[string]struct{}{
-	"RequestError":                           {},
-	"ProvisionedThroughputExceededException": {},
-	"Throttling":                             {},
-	"ThrottlingException":                    {},
-	"RequestLimitExceeded":                   {},
-	"RequestThrottled":                       {},
-}
-
-// 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 isCodeRetryable(code string) bool {
-	if _, ok := retryableCodes[code]; ok {
-		return true
-	}
-
-	return isCodeExpiredCreds(code)
-}
-
-func isCodeExpiredCreds(code string) bool {
-	_, ok := credsExpiredCodes[code]
-	return ok
-}
-
-// shouldRetry returns if the request should be retried.
-func shouldRetry(r *Request) bool {
-	if r.HTTPResponse.StatusCode >= 500 {
-		return true
-	}
-	if r.Error != nil {
-		if err, ok := r.Error.(awserr.Error); ok {
-			return isCodeRetryable(err.Code())
-		}
-	}
-	return false
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/service/serviceinfo/service_info.go

@@ -0,0 +1,15 @@
+package serviceinfo
+
+import "github.com/aws/aws-sdk-go/aws"
+
+// ServiceInfo wraps immutable data from the service.Service structure.
+type ServiceInfo struct {
+	Config        *aws.Config
+	ServiceName   string
+	APIVersion    string
+	Endpoint      string
+	SigningName   string
+	SigningRegion string
+	JSONVersion   string
+	TargetPrefix  string
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/types_test.go

@@ -1,56 +0,0 @@
-package aws
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestWriteAtBuffer(t *testing.T) {
-	b := &WriteAtBuffer{}
-
-	n, err := b.WriteAt([]byte{1}, 0)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	n, err = b.WriteAt([]byte{1, 1, 1}, 5)
-	assert.NoError(t, err)
-	assert.Equal(t, 3, n)
-
-	n, err = b.WriteAt([]byte{2}, 1)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	n, err = b.WriteAt([]byte{3}, 2)
-	assert.NoError(t, err)
-	assert.Equal(t, 1, n)
-
-	assert.Equal(t, []byte{1, 2, 3, 0, 0, 1, 1, 1}, b.Bytes())
-}
-
-func BenchmarkWriteAtBuffer(b *testing.B) {
-	buf := &WriteAtBuffer{}
-	r := rand.New(rand.NewSource(1))
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		to := r.Intn(10) * 4096
-		bs := make([]byte, to)
-		buf.WriteAt(bs, r.Int63n(10)*4096)
-	}
-}
-
-func BenchmarkWriteAtBufferParallel(b *testing.B) {
-	buf := &WriteAtBuffer{}
-	r := rand.New(rand.NewSource(1))
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			to := r.Intn(10) * 4096
-			bs := make([]byte, to)
-			buf.WriteAt(bs, r.Int63n(10)*4096)
-		}
-	})
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/version.go

@@ -5,4 +5,4 @@ package aws
 const SDKName = "aws-sdk-go"
 
 // SDKVersion is the version of this SDK
-const SDKVersion = "0.9.0rc1"
+const SDKVersion = "0.9.9"

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/endpoints/endpoints_test.go

@@ -1,28 +0,0 @@
-package endpoints
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGlobalEndpoints(t *testing.T) {
-	region := "mock-region-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts"}
-
-	for _, name := range svcs {
-		ep, sr := EndpointForRegion(name, region)
-		assert.Equal(t, name+".amazonaws.com", ep)
-		assert.Equal(t, "us-east-1", sr)
-	}
-}
-
-func TestServicesInCN(t *testing.T) {
-	region := "cn-north-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3"}
-
-	for _, name := range svcs {
-		ep, _ := EndpointForRegion(name, region)
-		assert.Equal(t, name+"."+region+".amazonaws.com.cn", ep)
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build.go

@@ -7,12 +7,12 @@ import (
 	"net/url"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
 )
 
 // Build builds a request for the EC2 protocol.
-func Build(r *service.Request) {
+func Build(r *request.Request) {
 	body := url.Values{
 		"Action":  {r.Operation.Name},
 		"Version": {r.Service.APIVersion},

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/build_test.go

@@ -1,862 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/defaults"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type InputService1ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService1ProtocolTest client.
-func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice1protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService1ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService1TestCaseOperation1 = "OperationName"
-
-// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *service.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService1TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) {
-	req, out := c.InputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService1TestShapeInputService1TestCaseOperation1Output struct {
-	metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService1TestShapeInputShape struct {
-	Bar *string `type:"string"`
-
-	Foo *string `type:"string"`
-
-	metadataInputService1TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService2ProtocolTest client.
-func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice2protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService2ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService2TestCaseOperation1 = "OperationName"
-
-// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *service.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService2TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) {
-	req, out := c.InputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService2TestShapeInputService2TestCaseOperation1Output struct {
-	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2TestShapeInputShape struct {
-	Bar *string `locationName:"barLocationName" type:"string"`
-
-	Foo *string `type:"string"`
-
-	Yuck *string `locationName:"yuckLocationName" queryName:"yuckQueryName" type:"string"`
-
-	metadataInputService2TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService3ProtocolTest client.
-func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice3protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService3ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService3TestCaseOperation1 = "OperationName"
-
-// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *service.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService3TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
-	req, out := c.InputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService3TestShapeInputService3TestCaseOperation1Output struct {
-	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeInputShape struct {
-	StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"`
-
-	metadataInputService3TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeStructType struct {
-	ScalarArg *string `locationName:"Scalar" type:"string"`
-
-	metadataInputService3TestShapeStructType `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeStructType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService4ProtocolTest client.
-func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice4protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService4ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService4TestCaseOperation1 = "OperationName"
-
-// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *service.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService4TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) {
-	req, out := c.InputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService4TestShapeInputService4TestCaseOperation1Output struct {
-	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4TestShapeInputShape struct {
-	ListArg []*string `type:"list"`
-
-	metadataInputService4TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService5ProtocolTest client.
-func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice5protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService5ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService5TestCaseOperation1 = "OperationName"
-
-// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *service.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService5TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
-	req, out := c.InputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService5TestShapeInputService5TestCaseOperation1Output struct {
-	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"`
-
-	metadataInputService5TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService6ProtocolTest client.
-func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice6protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService6ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService6TestCaseOperation1 = "OperationName"
-
-// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *service.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService6TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) {
-	req, out := c.InputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService6TestShapeInputService6TestCaseOperation1Output struct {
-	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"`
-
-	metadataInputService6TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService7ProtocolTest client.
-func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice7protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService7ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService7TestCaseOperation1 = "OperationName"
-
-// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *service.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService7TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
-	req, out := c.InputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService7TestShapeInputService7TestCaseOperation1Output struct {
-	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7TestShapeInputShape struct {
-	BlobArg []byte `type:"blob"`
-
-	metadataInputService7TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new InputService8ProtocolTest client.
-func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "inputservice8protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService8ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService8TestCaseOperation1 = "OperationName"
-
-// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *service.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
-	op := &service.Operation{
-		Name: opInputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService8TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) {
-	req, out := c.InputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService8TestShapeInputService8TestCaseOperation1Output struct {
-	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8TestShapeInputShape struct {
-	TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"`
-
-	metadataInputService8TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewInputService1ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService1TestShapeInputShape{
-		Bar: aws.String("val2"),
-		Foo: aws.String("val1"),
-	}
-	req, _ := svc.InputService1TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) {
-	svc := NewInputService2ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService2TestShapeInputShape{
-		Bar:  aws.String("val2"),
-		Foo:  aws.String("val1"),
-		Yuck: aws.String("val3"),
-	}
-	req, _ := svc.InputService2TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) {
-	svc := NewInputService3ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService3TestShapeInputShape{
-		StructArg: &InputService3TestShapeStructType{
-			ScalarArg: aws.String("foo"),
-		},
-	}
-	req, _ := svc.InputService3TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService4ProtocolTestListTypesCase1(t *testing.T) {
-	svc := NewInputService4ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService4TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("foo"),
-			aws.String("bar"),
-			aws.String("baz"),
-		},
-	}
-	req, _ := svc.InputService4TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListArg.1=foo&ListArg.2=bar&ListArg.3=baz&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) {
-	svc := NewInputService5ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService5TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService5TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) {
-	svc := NewInputService6ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService6TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService6TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
-	svc := NewInputService7ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService7TestShapeInputShape{
-		BlobArg: []byte("foo"),
-	}
-	req, _ := svc.InputService7TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
-	svc := NewInputService8ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService8TestShapeInputShape{
-		TimeArg: aws.Time(time.Unix(1422172800, 0)),
-	}
-	req, _ := svc.InputService8TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal.go

@@ -7,12 +7,12 @@ import (
 	"io"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
 )
 
 // Unmarshal unmarshals a response body for the EC2 protocol.
-func Unmarshal(r *service.Request) {
+func Unmarshal(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 	if r.DataFilled() {
 		decoder := xml.NewDecoder(r.HTTPResponse.Body)
@@ -25,7 +25,7 @@ func Unmarshal(r *service.Request) {
 }
 
 // UnmarshalMeta unmarshals response headers for the EC2 protocol.
-func UnmarshalMeta(r *service.Request) {
+func UnmarshalMeta(r *request.Request) {
 	// TODO implement unmarshaling of request IDs
 }
 
@@ -37,7 +37,7 @@ type xmlErrorResponse struct {
 }
 
 // UnmarshalError unmarshals a response error for the EC2 protocol.
-func UnmarshalError(r *service.Request) {
+func UnmarshalError(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 
 	resp := &xmlErrorResponse{}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/ec2query/unmarshal_test.go

@@ -1,818 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/defaults"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type OutputService1ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService1ProtocolTest client.
-func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice1protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService1ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService1TestCaseOperation1 = "OperationName"
-
-// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *service.Request, output *OutputService1TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService1TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
-	req, out := c.OutputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService1TestShapeOutputShape struct {
-	Char *string `type:"character"`
-
-	Double *float64 `type:"double"`
-
-	FalseBool *bool `type:"boolean"`
-
-	Float *float64 `type:"float"`
-
-	Long *int64 `type:"long"`
-
-	Num *int64 `locationName:"FooNum" type:"integer"`
-
-	Str *string `type:"string"`
-
-	TrueBool *bool `type:"boolean"`
-
-	metadataOutputService1TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService2ProtocolTest client.
-func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice2protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService2ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService2TestCaseOperation1 = "OperationName"
-
-// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *service.Request, output *OutputService2TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService2TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (*OutputService2TestShapeOutputShape, error) {
-	req, out := c.OutputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2TestShapeOutputShape struct {
-	Blob []byte `type:"blob"`
-
-	metadataOutputService2TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService3ProtocolTest client.
-func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice3protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService3ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService3TestCaseOperation1 = "OperationName"
-
-// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *service.Request, output *OutputService3TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService3TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (*OutputService3TestShapeOutputShape, error) {
-	req, out := c.OutputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3TestShapeOutputShape struct {
-	ListMember []*string `type:"list"`
-
-	metadataOutputService3TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService4ProtocolTest client.
-func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice4protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService4ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService4TestCaseOperation1 = "OperationName"
-
-// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *service.Request, output *OutputService4TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService4TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
-	req, out := c.OutputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4TestShapeOutputShape struct {
-	ListMember []*string `locationNameList:"item" type:"list"`
-
-	metadataOutputService4TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService5ProtocolTest client.
-func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice5protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService5ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService5TestCaseOperation1 = "OperationName"
-
-// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *service.Request, output *OutputService5TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService5TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (*OutputService5TestShapeOutputShape, error) {
-	req, out := c.OutputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5TestShapeOutputShape struct {
-	ListMember []*string `type:"list" flattened:"true"`
-
-	metadataOutputService5TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService6ProtocolTest client.
-func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice6protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService6ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService6TestCaseOperation1 = "OperationName"
-
-// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *service.Request, output *OutputService6TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService6TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (*OutputService6TestShapeOutputShape, error) {
-	req, out := c.OutputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeOutputShape struct {
-	Map map[string]*OutputService6TestShapeStructureType `type:"map"`
-
-	metadataOutputService6TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeStructureType struct {
-	Foo *string `locationName:"foo" type:"string"`
-
-	metadataOutputService6TestShapeStructureType `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeStructureType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService7ProtocolTest client.
-func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice7protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService7ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService7TestCaseOperation1 = "OperationName"
-
-// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *service.Request, output *OutputService7TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService7TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (*OutputService7TestShapeOutputShape, error) {
-	req, out := c.OutputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7TestShapeOutputShape struct {
-	Map map[string]*string `type:"map" flattened:"true"`
-
-	metadataOutputService7TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8ProtocolTest struct {
-	*service.Service
-}
-
-// New returns a new OutputService8ProtocolTest client.
-func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
-	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
-		ServiceName: "outputservice8protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService8ProtocolTest) newRequest(op *service.Operation, params, data interface{}) *service.Request {
-	req := service.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService8TestCaseOperation1 = "OperationName"
-
-// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *service.Request, output *OutputService8TestShapeOutputShape) {
-	op := &service.Operation{
-		Name: opOutputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService8TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (*OutputService8TestShapeOutputShape, error) {
-	req, out := c.OutputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8TestShapeOutputShape struct {
-	Map map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
-
-	metadataOutputService8TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewOutputService1ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Str>myname</Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><RequestId>request-id</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService1TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "a", *out.Char)
-	assert.Equal(t, 1.3, *out.Double)
-	assert.Equal(t, false, *out.FalseBool)
-	assert.Equal(t, 1.2, *out.Float)
-	assert.Equal(t, int64(200), *out.Long)
-	assert.Equal(t, int64(123), *out.Num)
-	assert.Equal(t, "myname", *out.Str)
-	assert.Equal(t, true, *out.TrueBool)
-
-}
-
-func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
-	svc := NewOutputService2ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Blob>dmFsdWU=</Blob><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService2TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "value", string(out.Blob))
-
-}
-
-func TestOutputService3ProtocolTestListsCase1(t *testing.T) {
-	svc := NewOutputService3ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><member>abc</member><member>123</member></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService3TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
-	svc := NewOutputService4ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><item>abc</item><item>123</item></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService4TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) {
-	svc := NewOutputService5ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember>abc</ListMember><ListMember>123</ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService5TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) {
-	svc := NewOutputService6ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService6TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"].Foo)
-	assert.Equal(t, "bar", *out.Map["qux"].Foo)
-
-}
-
-func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) {
-	svc := NewOutputService7ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService7TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}
-
-func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) {
-	svc := NewOutputService8ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><foo>qux</foo><bar>bar</bar></Map><Map><foo>baz</foo><bar>bam</bar></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService8TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/build.go

@@ -7,12 +7,12 @@ import (
 	"net/url"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
 )
 
 // Build builds a request for an AWS Query service.
-func Build(r *service.Request) {
+func Build(r *request.Request) {
 	body := url.Values{
 		"Action":  {r.Operation.Name},
 		"Version": {r.Service.APIVersion},

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal.go

@@ -6,12 +6,12 @@ import (
 	"encoding/xml"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
 )
 
 // Unmarshal unmarshals a response for an AWS Query service.
-func Unmarshal(r *service.Request) {
+func Unmarshal(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 	if r.DataFilled() {
 		decoder := xml.NewDecoder(r.HTTPResponse.Body)
@@ -24,6 +24,6 @@ func Unmarshal(r *service.Request) {
 }
 
 // UnmarshalMeta unmarshals header response values for an AWS Query service.
-func UnmarshalMeta(r *service.Request) {
+func UnmarshalMeta(r *request.Request) {
 	// TODO implement unmarshaling of request IDs
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/query/unmarshal_error.go

@@ -5,7 +5,7 @@ import (
 	"io"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 type xmlErrorResponse struct {
@@ -16,7 +16,7 @@ type xmlErrorResponse struct {
 }
 
 // UnmarshalError unmarshals an error response for an AWS Query service.
-func UnmarshalError(r *service.Request) {
+func UnmarshalError(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 
 	resp := &xmlErrorResponse{}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/build.go

@@ -14,7 +14,7 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 // RFC822 returns an RFC822 formatted timestamp for AWS protocols
@@ -37,7 +37,7 @@ func init() {
 }
 
 // Build builds the REST component of a service request.
-func Build(r *service.Request) {
+func Build(r *request.Request) {
 	if r.ParamsFilled() {
 		v := reflect.ValueOf(r.Params).Elem()
 		buildLocationElements(r, v)
@@ -45,7 +45,7 @@ func Build(r *service.Request) {
 	}
 }
 
-func buildLocationElements(r *service.Request, v reflect.Value) {
+func buildLocationElements(r *request.Request, v reflect.Value) {
 	query := r.HTTPRequest.URL.Query()
 
 	for i := 0; i < v.NumField(); i++ {
@@ -87,7 +87,7 @@ func buildLocationElements(r *service.Request, v reflect.Value) {
 	updatePath(r.HTTPRequest.URL, r.HTTPRequest.URL.Path)
 }
 
-func buildBody(r *service.Request, v reflect.Value) {
+func buildBody(r *request.Request, v reflect.Value) {
 	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
 		if payloadName := field.Tag.Get("payload"); payloadName != "" {
 			pfield, _ := v.Type().FieldByName(payloadName)
@@ -112,7 +112,7 @@ func buildBody(r *service.Request, v reflect.Value) {
 	}
 }
 
-func buildHeader(r *service.Request, v reflect.Value, name string) {
+func buildHeader(r *request.Request, v reflect.Value, name string) {
 	str, err := convertType(v)
 	if err != nil {
 		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
@@ -121,7 +121,7 @@ func buildHeader(r *service.Request, v reflect.Value, name string) {
 	}
 }
 
-func buildHeaderMap(r *service.Request, v reflect.Value, prefix string) {
+func buildHeaderMap(r *request.Request, v reflect.Value, prefix string) {
 	for _, key := range v.MapKeys() {
 		str, err := convertType(v.MapIndex(key))
 		if err != nil {
@@ -132,7 +132,7 @@ func buildHeaderMap(r *service.Request, v reflect.Value, prefix string) {
 	}
 }
 
-func buildURI(r *service.Request, v reflect.Value, name string) {
+func buildURI(r *request.Request, v reflect.Value, name string) {
 	value, err := convertType(v)
 	if err != nil {
 		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
@@ -144,7 +144,7 @@ func buildURI(r *service.Request, v reflect.Value, name string) {
 	}
 }
 
-func buildQueryString(r *service.Request, v reflect.Value, name string, query url.Values) {
+func buildQueryString(r *request.Request, v reflect.Value, name string, query url.Values) {
 	str, err := convertType(v)
 	if err != nil {
 		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/rest/unmarshal.go

@@ -12,19 +12,27 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 // Unmarshal unmarshals the REST component of a response in a REST service.
-func Unmarshal(r *service.Request) {
+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.DataFilled() {
+		v := reflect.Indirect(reflect.ValueOf(r.Data))
 		unmarshalLocationElements(r, v)
 	}
 }
 
-func unmarshalBody(r *service.Request, v reflect.Value) {
+func unmarshalBody(r *request.Request, v reflect.Value) {
 	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
 		if payloadName := field.Tag.Get("payload"); payloadName != "" {
 			pfield, _ := v.Type().FieldByName(payloadName)
@@ -65,7 +73,7 @@ func unmarshalBody(r *service.Request, v reflect.Value) {
 	}
 }
 
-func unmarshalLocationElements(r *service.Request, v reflect.Value) {
+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]) {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/protocol/restxml/restxml.go

@@ -10,21 +10,21 @@ import (
 	"encoding/xml"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/query"
 	"github.com/aws/aws-sdk-go/internal/protocol/rest"
 	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
 )
 
 // Build builds a request payload for the REST XML protocol.
-func Build(r *service.Request) {
+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.New("SerializationError", "failed to enode rest XML request", err)
+			r.Error = awserr.New("SerializationError", "failed to encode rest XML request", err)
 			return
 		}
 		r.SetBufferBody(buf.Bytes())
@@ -32,7 +32,7 @@ func Build(r *service.Request) {
 }
 
 // Unmarshal unmarshals a payload response for the REST XML protocol.
-func Unmarshal(r *service.Request) {
+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)
@@ -41,15 +41,17 @@ func Unmarshal(r *service.Request) {
 			r.Error = awserr.New("SerializationError", "failed to decode REST XML response", err)
 			return
 		}
+	} else {
+		rest.Unmarshal(r)
 	}
 }
 
 // UnmarshalMeta unmarshals response headers for the REST XML protocol.
-func UnmarshalMeta(r *service.Request) {
+func UnmarshalMeta(r *request.Request) {
-	rest.Unmarshal(r)
+	rest.UnmarshalMeta(r)
 }
 
 // UnmarshalError unmarshals a response error for the REST XML protocol.
-func UnmarshalError(r *service.Request) {
+func UnmarshalError(r *request.Request) {
 	query.UnmarshalError(r)
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/functional_test.go

@@ -1,43 +0,0 @@
-package v4_test
-
-import (
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func TestPresignHandler(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutObjectRequest(&s3.PutObjectInput{
-		Bucket:             aws.String("bucket"),
-		Key:                aws.String("key"),
-		ContentDisposition: aws.String("a+b c$d"),
-		ACL:                aws.String("public-read"),
-	})
-	req.Time = time.Unix(0, 0)
-	urlstr, err := req.Presign(5 * time.Minute)
-
-	assert.NoError(t, err)
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-acl"
-	expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2"
-	expectedCred := "AKID/19700101/mock-region/s3/aws4_request"
-
-	u, _ := url.Parse(urlstr)
-	urlQ := u.Query()
-	assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date"))
-	assert.Equal(t, "300", urlQ.Get("X-Amz-Expires"))
-
-	assert.NotContains(t, urlstr, "+") // + encoded as %20
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4.go

@@ -16,7 +16,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/internal/protocol/rest"
 )
 
@@ -64,7 +64,7 @@ type signer struct {
 // Will sign the requests with the service config's Credentials object
 // Signing is skipped if the credentials is the credentials.AnonymousCredentials
 // object.
-func Sign(req *service.Request) {
+func Sign(req *request.Request) {
 	// If the request does not need to be signed ignore the signing of the
 	// request if the AnonymousCredentials object is used.
 	if req.Service.Config.Credentials == credentials.AnonymousCredentials {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/internal/signer/v4/v4_test.go

@@ -1,246 +0,0 @@
-package v4
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/stretchr/testify/assert"
-)
-
-func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
-	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
-	reader := strings.NewReader(body)
-	req, _ := http.NewRequest("POST", endpoint, reader)
-	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
-	req.Header.Add("X-Amz-Target", "prefix.Operation")
-	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
-	req.Header.Add("Content-Length", string(len(body)))
-	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* (+)")
-
-	return signer{
-		Request:     req,
-		Time:        signTime,
-		ExpireTime:  expireTime,
-		Query:       req.URL.Query(),
-		Body:        reader,
-		ServiceName: serviceName,
-		Region:      region,
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-	}
-}
-
-func removeWS(text string) string {
-	text = strings.Replace(text, " ", "", -1)
-	text = strings.Replace(text, "\n", "", -1)
-	text = strings.Replace(text, "\t", "", -1)
-	return text
-}
-
-func assertEqual(t *testing.T, expected, given string) {
-	if removeWS(expected) != removeWS(given) {
-		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
-	}
-}
-
-func TestPresignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
-	expectedSig := "5eeedebf6f995145ce56daa02902d10485246d3defb34f97b973c1f40ab82d36"
-	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
-
-	q := signer.Request.URL.Query()
-	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=69ada33fec48180dab153576e4dd80c4e04124f80dda3eccfed8a67c2b91ed5e"
-
-	q := signer.Request.Header
-	assert.Equal(t, expectedSig, q.Get("Authorization"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignEmptyBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "")
-	signer.Body = nil
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash)
-}
-
-func TestSignBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-}
-
-func TestSignSeekedBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "   hello")
-	signer.Body.Read(make([]byte, 3)) // consume first 3 bytes so body is now "hello"
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-
-	start, _ := signer.Body.Seek(0, 1)
-	assert.Equal(t, int64(3), start)
-}
-
-func TestPresignEmptyBodyS3(t *testing.T) {
-	signer := buildSigner("s3", "us-east-1", time.Now(), 5*time.Minute, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "UNSIGNED-PAYLOAD", hash)
-}
-
-func TestSignPrecomputedBodyChecksum(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.Request.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "PRECOMPUTED", hash)
-}
-
-func TestAnonymousCredentials(t *testing.T) {
-	r := service.NewRequest(
-		service.NewService(&aws.Config{Credentials: credentials.AnonymousCredentials}),
-		&service.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-
-	urlQ := r.HTTPRequest.URL.Query()
-	assert.Empty(t, urlQ.Get("X-Amz-Signature"))
-	assert.Empty(t, urlQ.Get("X-Amz-Credential"))
-	assert.Empty(t, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Empty(t, urlQ.Get("X-Amz-Date"))
-
-	hQ := r.HTTPRequest.Header
-	assert.Empty(t, hQ.Get("Authorization"))
-	assert.Empty(t, hQ.Get("X-Amz-Date"))
-}
-
-func TestIgnoreResignRequestWithValidCreds(t *testing.T) {
-	r := service.NewRequest(
-		service.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&service.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("Authorization")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestIgnorePreResignRequestWithValidCreds(t *testing.T) {
-	r := service.NewRequest(
-		service.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&service.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("X-Amz-Signature")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("X-Amz-Signature"))
-}
-
-func TestResignRequestExpiredCreds(t *testing.T) {
-	creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-	r := service.NewRequest(
-		service.NewService(&aws.Config{Credentials: creds}),
-		&service.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-	querySig := r.HTTPRequest.Header.Get("Authorization")
-
-	creds.Expire()
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestPreResignRequestExpiredCreds(t *testing.T) {
-	provider := &credentials.StaticProvider{credentials.Value{"AKID", "SECRET", "SESSION"}}
-	creds := credentials.NewCredentials(provider)
-	r := service.NewRequest(
-		service.NewService(&aws.Config{Credentials: creds}),
-		&service.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature")
-
-	creds.Expire()
-	r.Time = time.Now().Add(time.Hour * 48)
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"))
-}
-
-func BenchmarkPresignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
-
-func BenchmarkSignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations.go

@@ -4,18 +4,18 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 func init() {
-	initRequest = func(r *service.Request) {
+	initRequest = func(r *request.Request) {
 		if r.Operation.Name == opCopySnapshot { // fill the PresignedURL parameter
 			r.Handlers.Build.PushFront(fillPresignedURL)
 		}
 	}
 }
 
-func fillPresignedURL(r *service.Request) {
+func fillPresignedURL(r *request.Request) {
 	if !r.ParamsFilled() {
 		return
 	}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/customizations_test.go

@@ -1,36 +0,0 @@
-package ec2_test
-
-import (
-	"io/ioutil"
-	"net/url"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func TestCopySnapshotPresignedURL(t *testing.T) {
-	svc := ec2.New(&aws.Config{Region: aws.String("us-west-2")})
-
-	assert.NotPanics(t, func() {
-		// Doesn't panic on nil input
-		req, _ := svc.CopySnapshotRequest(nil)
-		req.Sign()
-	})
-
-	req, _ := svc.CopySnapshotRequest(&ec2.CopySnapshotInput{
-		SourceRegion:     aws.String("us-west-1"),
-		SourceSnapshotId: aws.String("snap-id"),
-	})
-	req.Sign()
-
-	b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
-	q, _ := url.ParseQuery(string(b))
-	url, _ := url.QueryUnescape(q.Get("PresignedUrl"))
-	assert.Equal(t, "us-west-2", q.Get("DestinationRegion"))
-	assert.Regexp(t, `^https://ec2\.us-west-1\.amazon.+&DestinationRegion=us-west-2`, url)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface.go

@@ -4,753 +4,753 @@
 package ec2iface
 
 import (
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ec2"
 )
 
 // EC2API is the interface type for ec2.EC2.
 type EC2API interface {
-	AcceptVpcPeeringConnectionRequest(*ec2.AcceptVpcPeeringConnectionInput) (*service.Request, *ec2.AcceptVpcPeeringConnectionOutput)
+	AcceptVpcPeeringConnectionRequest(*ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput)
 
 	AcceptVpcPeeringConnection(*ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error)
 
-	AllocateAddressRequest(*ec2.AllocateAddressInput) (*service.Request, *ec2.AllocateAddressOutput)
+	AllocateAddressRequest(*ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput)
 
 	AllocateAddress(*ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error)
 
-	AssignPrivateIpAddressesRequest(*ec2.AssignPrivateIpAddressesInput) (*service.Request, *ec2.AssignPrivateIpAddressesOutput)
+	AssignPrivateIpAddressesRequest(*ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput)
 
 	AssignPrivateIpAddresses(*ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error)
 
-	AssociateAddressRequest(*ec2.AssociateAddressInput) (*service.Request, *ec2.AssociateAddressOutput)
+	AssociateAddressRequest(*ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput)
 
 	AssociateAddress(*ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error)
 
-	AssociateDhcpOptionsRequest(*ec2.AssociateDhcpOptionsInput) (*service.Request, *ec2.AssociateDhcpOptionsOutput)
+	AssociateDhcpOptionsRequest(*ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput)
 
 	AssociateDhcpOptions(*ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error)
 
-	AssociateRouteTableRequest(*ec2.AssociateRouteTableInput) (*service.Request, *ec2.AssociateRouteTableOutput)
+	AssociateRouteTableRequest(*ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput)
 
 	AssociateRouteTable(*ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error)
 
-	AttachClassicLinkVpcRequest(*ec2.AttachClassicLinkVpcInput) (*service.Request, *ec2.AttachClassicLinkVpcOutput)
+	AttachClassicLinkVpcRequest(*ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput)
 
 	AttachClassicLinkVpc(*ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error)
 
-	AttachInternetGatewayRequest(*ec2.AttachInternetGatewayInput) (*service.Request, *ec2.AttachInternetGatewayOutput)
+	AttachInternetGatewayRequest(*ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput)
 
 	AttachInternetGateway(*ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error)
 
-	AttachNetworkInterfaceRequest(*ec2.AttachNetworkInterfaceInput) (*service.Request, *ec2.AttachNetworkInterfaceOutput)
+	AttachNetworkInterfaceRequest(*ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput)
 
 	AttachNetworkInterface(*ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error)
 
-	AttachVolumeRequest(*ec2.AttachVolumeInput) (*service.Request, *ec2.VolumeAttachment)
+	AttachVolumeRequest(*ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment)
 
 	AttachVolume(*ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error)
 
-	AttachVpnGatewayRequest(*ec2.AttachVpnGatewayInput) (*service.Request, *ec2.AttachVpnGatewayOutput)
+	AttachVpnGatewayRequest(*ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput)
 
 	AttachVpnGateway(*ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error)
 
-	AuthorizeSecurityGroupEgressRequest(*ec2.AuthorizeSecurityGroupEgressInput) (*service.Request, *ec2.AuthorizeSecurityGroupEgressOutput)
+	AuthorizeSecurityGroupEgressRequest(*ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput)
 
 	AuthorizeSecurityGroupEgress(*ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error)
 
-	AuthorizeSecurityGroupIngressRequest(*ec2.AuthorizeSecurityGroupIngressInput) (*service.Request, *ec2.AuthorizeSecurityGroupIngressOutput)
+	AuthorizeSecurityGroupIngressRequest(*ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput)
 
 	AuthorizeSecurityGroupIngress(*ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error)
 
-	BundleInstanceRequest(*ec2.BundleInstanceInput) (*service.Request, *ec2.BundleInstanceOutput)
+	BundleInstanceRequest(*ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput)
 
 	BundleInstance(*ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error)
 
-	CancelBundleTaskRequest(*ec2.CancelBundleTaskInput) (*service.Request, *ec2.CancelBundleTaskOutput)
+	CancelBundleTaskRequest(*ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput)
 
 	CancelBundleTask(*ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error)
 
-	CancelConversionTaskRequest(*ec2.CancelConversionTaskInput) (*service.Request, *ec2.CancelConversionTaskOutput)
+	CancelConversionTaskRequest(*ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput)
 
 	CancelConversionTask(*ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error)
 
-	CancelExportTaskRequest(*ec2.CancelExportTaskInput) (*service.Request, *ec2.CancelExportTaskOutput)
+	CancelExportTaskRequest(*ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput)
 
 	CancelExportTask(*ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error)
 
-	CancelImportTaskRequest(*ec2.CancelImportTaskInput) (*service.Request, *ec2.CancelImportTaskOutput)
+	CancelImportTaskRequest(*ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput)
 
 	CancelImportTask(*ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error)
 
-	CancelReservedInstancesListingRequest(*ec2.CancelReservedInstancesListingInput) (*service.Request, *ec2.CancelReservedInstancesListingOutput)
+	CancelReservedInstancesListingRequest(*ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput)
 
 	CancelReservedInstancesListing(*ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error)
 
-	CancelSpotFleetRequestsRequest(*ec2.CancelSpotFleetRequestsInput) (*service.Request, *ec2.CancelSpotFleetRequestsOutput)
+	CancelSpotFleetRequestsRequest(*ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput)
 
 	CancelSpotFleetRequests(*ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error)
 
-	CancelSpotInstanceRequestsRequest(*ec2.CancelSpotInstanceRequestsInput) (*service.Request, *ec2.CancelSpotInstanceRequestsOutput)
+	CancelSpotInstanceRequestsRequest(*ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput)
 
 	CancelSpotInstanceRequests(*ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error)
 
-	ConfirmProductInstanceRequest(*ec2.ConfirmProductInstanceInput) (*service.Request, *ec2.ConfirmProductInstanceOutput)
+	ConfirmProductInstanceRequest(*ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput)
 
 	ConfirmProductInstance(*ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error)
 
-	CopyImageRequest(*ec2.CopyImageInput) (*service.Request, *ec2.CopyImageOutput)
+	CopyImageRequest(*ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput)
 
 	CopyImage(*ec2.CopyImageInput) (*ec2.CopyImageOutput, error)
 
-	CopySnapshotRequest(*ec2.CopySnapshotInput) (*service.Request, *ec2.CopySnapshotOutput)
+	CopySnapshotRequest(*ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput)
 
 	CopySnapshot(*ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error)
 
-	CreateCustomerGatewayRequest(*ec2.CreateCustomerGatewayInput) (*service.Request, *ec2.CreateCustomerGatewayOutput)
+	CreateCustomerGatewayRequest(*ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput)
 
 	CreateCustomerGateway(*ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error)
 
-	CreateDhcpOptionsRequest(*ec2.CreateDhcpOptionsInput) (*service.Request, *ec2.CreateDhcpOptionsOutput)
+	CreateDhcpOptionsRequest(*ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput)
 
 	CreateDhcpOptions(*ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error)
 
-	CreateFlowLogsRequest(*ec2.CreateFlowLogsInput) (*service.Request, *ec2.CreateFlowLogsOutput)
+	CreateFlowLogsRequest(*ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput)
 
 	CreateFlowLogs(*ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error)
 
-	CreateImageRequest(*ec2.CreateImageInput) (*service.Request, *ec2.CreateImageOutput)
+	CreateImageRequest(*ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput)
 
 	CreateImage(*ec2.CreateImageInput) (*ec2.CreateImageOutput, error)
 
-	CreateInstanceExportTaskRequest(*ec2.CreateInstanceExportTaskInput) (*service.Request, *ec2.CreateInstanceExportTaskOutput)
+	CreateInstanceExportTaskRequest(*ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput)
 
 	CreateInstanceExportTask(*ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error)
 
-	CreateInternetGatewayRequest(*ec2.CreateInternetGatewayInput) (*service.Request, *ec2.CreateInternetGatewayOutput)
+	CreateInternetGatewayRequest(*ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput)
 
 	CreateInternetGateway(*ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error)
 
-	CreateKeyPairRequest(*ec2.CreateKeyPairInput) (*service.Request, *ec2.CreateKeyPairOutput)
+	CreateKeyPairRequest(*ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput)
 
 	CreateKeyPair(*ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error)
 
-	CreateNetworkAclRequest(*ec2.CreateNetworkAclInput) (*service.Request, *ec2.CreateNetworkAclOutput)
+	CreateNetworkAclRequest(*ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput)
 
 	CreateNetworkAcl(*ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error)
 
-	CreateNetworkAclEntryRequest(*ec2.CreateNetworkAclEntryInput) (*service.Request, *ec2.CreateNetworkAclEntryOutput)
+	CreateNetworkAclEntryRequest(*ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput)
 
 	CreateNetworkAclEntry(*ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error)
 
-	CreateNetworkInterfaceRequest(*ec2.CreateNetworkInterfaceInput) (*service.Request, *ec2.CreateNetworkInterfaceOutput)
+	CreateNetworkInterfaceRequest(*ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput)
 
 	CreateNetworkInterface(*ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error)
 
-	CreatePlacementGroupRequest(*ec2.CreatePlacementGroupInput) (*service.Request, *ec2.CreatePlacementGroupOutput)
+	CreatePlacementGroupRequest(*ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput)
 
 	CreatePlacementGroup(*ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error)
 
-	CreateReservedInstancesListingRequest(*ec2.CreateReservedInstancesListingInput) (*service.Request, *ec2.CreateReservedInstancesListingOutput)
+	CreateReservedInstancesListingRequest(*ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput)
 
 	CreateReservedInstancesListing(*ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error)
 
-	CreateRouteRequest(*ec2.CreateRouteInput) (*service.Request, *ec2.CreateRouteOutput)
+	CreateRouteRequest(*ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput)
 
 	CreateRoute(*ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error)
 
-	CreateRouteTableRequest(*ec2.CreateRouteTableInput) (*service.Request, *ec2.CreateRouteTableOutput)
+	CreateRouteTableRequest(*ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput)
 
 	CreateRouteTable(*ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error)
 
-	CreateSecurityGroupRequest(*ec2.CreateSecurityGroupInput) (*service.Request, *ec2.CreateSecurityGroupOutput)
+	CreateSecurityGroupRequest(*ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput)
 
 	CreateSecurityGroup(*ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error)
 
-	CreateSnapshotRequest(*ec2.CreateSnapshotInput) (*service.Request, *ec2.Snapshot)
+	CreateSnapshotRequest(*ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot)
 
 	CreateSnapshot(*ec2.CreateSnapshotInput) (*ec2.Snapshot, error)
 
-	CreateSpotDatafeedSubscriptionRequest(*ec2.CreateSpotDatafeedSubscriptionInput) (*service.Request, *ec2.CreateSpotDatafeedSubscriptionOutput)
+	CreateSpotDatafeedSubscriptionRequest(*ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput)
 
 	CreateSpotDatafeedSubscription(*ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error)
 
-	CreateSubnetRequest(*ec2.CreateSubnetInput) (*service.Request, *ec2.CreateSubnetOutput)
+	CreateSubnetRequest(*ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput)
 
 	CreateSubnet(*ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error)
 
-	CreateTagsRequest(*ec2.CreateTagsInput) (*service.Request, *ec2.CreateTagsOutput)
+	CreateTagsRequest(*ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput)
 
 	CreateTags(*ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error)
 
-	CreateVolumeRequest(*ec2.CreateVolumeInput) (*service.Request, *ec2.Volume)
+	CreateVolumeRequest(*ec2.CreateVolumeInput) (*request.Request, *ec2.Volume)
 
 	CreateVolume(*ec2.CreateVolumeInput) (*ec2.Volume, error)
 
-	CreateVpcRequest(*ec2.CreateVpcInput) (*service.Request, *ec2.CreateVpcOutput)
+	CreateVpcRequest(*ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput)
 
 	CreateVpc(*ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error)
 
-	CreateVpcEndpointRequest(*ec2.CreateVpcEndpointInput) (*service.Request, *ec2.CreateVpcEndpointOutput)
+	CreateVpcEndpointRequest(*ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput)
 
 	CreateVpcEndpoint(*ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error)
 
-	CreateVpcPeeringConnectionRequest(*ec2.CreateVpcPeeringConnectionInput) (*service.Request, *ec2.CreateVpcPeeringConnectionOutput)
+	CreateVpcPeeringConnectionRequest(*ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput)
 
 	CreateVpcPeeringConnection(*ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error)
 
-	CreateVpnConnectionRequest(*ec2.CreateVpnConnectionInput) (*service.Request, *ec2.CreateVpnConnectionOutput)
+	CreateVpnConnectionRequest(*ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput)
 
 	CreateVpnConnection(*ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error)
 
-	CreateVpnConnectionRouteRequest(*ec2.CreateVpnConnectionRouteInput) (*service.Request, *ec2.CreateVpnConnectionRouteOutput)
+	CreateVpnConnectionRouteRequest(*ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput)
 
 	CreateVpnConnectionRoute(*ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error)
 
-	CreateVpnGatewayRequest(*ec2.CreateVpnGatewayInput) (*service.Request, *ec2.CreateVpnGatewayOutput)
+	CreateVpnGatewayRequest(*ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput)
 
 	CreateVpnGateway(*ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error)
 
-	DeleteCustomerGatewayRequest(*ec2.DeleteCustomerGatewayInput) (*service.Request, *ec2.DeleteCustomerGatewayOutput)
+	DeleteCustomerGatewayRequest(*ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput)
 
 	DeleteCustomerGateway(*ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error)
 
-	DeleteDhcpOptionsRequest(*ec2.DeleteDhcpOptionsInput) (*service.Request, *ec2.DeleteDhcpOptionsOutput)
+	DeleteDhcpOptionsRequest(*ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput)
 
 	DeleteDhcpOptions(*ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error)
 
-	DeleteFlowLogsRequest(*ec2.DeleteFlowLogsInput) (*service.Request, *ec2.DeleteFlowLogsOutput)
+	DeleteFlowLogsRequest(*ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput)
 
 	DeleteFlowLogs(*ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error)
 
-	DeleteInternetGatewayRequest(*ec2.DeleteInternetGatewayInput) (*service.Request, *ec2.DeleteInternetGatewayOutput)
+	DeleteInternetGatewayRequest(*ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput)
 
 	DeleteInternetGateway(*ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error)
 
-	DeleteKeyPairRequest(*ec2.DeleteKeyPairInput) (*service.Request, *ec2.DeleteKeyPairOutput)
+	DeleteKeyPairRequest(*ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput)
 
 	DeleteKeyPair(*ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error)
 
-	DeleteNetworkAclRequest(*ec2.DeleteNetworkAclInput) (*service.Request, *ec2.DeleteNetworkAclOutput)
+	DeleteNetworkAclRequest(*ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput)
 
 	DeleteNetworkAcl(*ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error)
 
-	DeleteNetworkAclEntryRequest(*ec2.DeleteNetworkAclEntryInput) (*service.Request, *ec2.DeleteNetworkAclEntryOutput)
+	DeleteNetworkAclEntryRequest(*ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput)
 
 	DeleteNetworkAclEntry(*ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error)
 
-	DeleteNetworkInterfaceRequest(*ec2.DeleteNetworkInterfaceInput) (*service.Request, *ec2.DeleteNetworkInterfaceOutput)
+	DeleteNetworkInterfaceRequest(*ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput)
 
 	DeleteNetworkInterface(*ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error)
 
-	DeletePlacementGroupRequest(*ec2.DeletePlacementGroupInput) (*service.Request, *ec2.DeletePlacementGroupOutput)
+	DeletePlacementGroupRequest(*ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput)
 
 	DeletePlacementGroup(*ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error)
 
-	DeleteRouteRequest(*ec2.DeleteRouteInput) (*service.Request, *ec2.DeleteRouteOutput)
+	DeleteRouteRequest(*ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput)
 
 	DeleteRoute(*ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error)
 
-	DeleteRouteTableRequest(*ec2.DeleteRouteTableInput) (*service.Request, *ec2.DeleteRouteTableOutput)
+	DeleteRouteTableRequest(*ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput)
 
 	DeleteRouteTable(*ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error)
 
-	DeleteSecurityGroupRequest(*ec2.DeleteSecurityGroupInput) (*service.Request, *ec2.DeleteSecurityGroupOutput)
+	DeleteSecurityGroupRequest(*ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput)
 
 	DeleteSecurityGroup(*ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error)
 
-	DeleteSnapshotRequest(*ec2.DeleteSnapshotInput) (*service.Request, *ec2.DeleteSnapshotOutput)
+	DeleteSnapshotRequest(*ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput)
 
 	DeleteSnapshot(*ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error)
 
-	DeleteSpotDatafeedSubscriptionRequest(*ec2.DeleteSpotDatafeedSubscriptionInput) (*service.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput)
+	DeleteSpotDatafeedSubscriptionRequest(*ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput)
 
 	DeleteSpotDatafeedSubscription(*ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error)
 
-	DeleteSubnetRequest(*ec2.DeleteSubnetInput) (*service.Request, *ec2.DeleteSubnetOutput)
+	DeleteSubnetRequest(*ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput)
 
 	DeleteSubnet(*ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error)
 
-	DeleteTagsRequest(*ec2.DeleteTagsInput) (*service.Request, *ec2.DeleteTagsOutput)
+	DeleteTagsRequest(*ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput)
 
 	DeleteTags(*ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error)
 
-	DeleteVolumeRequest(*ec2.DeleteVolumeInput) (*service.Request, *ec2.DeleteVolumeOutput)
+	DeleteVolumeRequest(*ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput)
 
 	DeleteVolume(*ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error)
 
-	DeleteVpcRequest(*ec2.DeleteVpcInput) (*service.Request, *ec2.DeleteVpcOutput)
+	DeleteVpcRequest(*ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput)
 
 	DeleteVpc(*ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error)
 
-	DeleteVpcEndpointsRequest(*ec2.DeleteVpcEndpointsInput) (*service.Request, *ec2.DeleteVpcEndpointsOutput)
+	DeleteVpcEndpointsRequest(*ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput)
 
 	DeleteVpcEndpoints(*ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error)
 
-	DeleteVpcPeeringConnectionRequest(*ec2.DeleteVpcPeeringConnectionInput) (*service.Request, *ec2.DeleteVpcPeeringConnectionOutput)
+	DeleteVpcPeeringConnectionRequest(*ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput)
 
 	DeleteVpcPeeringConnection(*ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error)
 
-	DeleteVpnConnectionRequest(*ec2.DeleteVpnConnectionInput) (*service.Request, *ec2.DeleteVpnConnectionOutput)
+	DeleteVpnConnectionRequest(*ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput)
 
 	DeleteVpnConnection(*ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error)
 
-	DeleteVpnConnectionRouteRequest(*ec2.DeleteVpnConnectionRouteInput) (*service.Request, *ec2.DeleteVpnConnectionRouteOutput)
+	DeleteVpnConnectionRouteRequest(*ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput)
 
 	DeleteVpnConnectionRoute(*ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error)
 
-	DeleteVpnGatewayRequest(*ec2.DeleteVpnGatewayInput) (*service.Request, *ec2.DeleteVpnGatewayOutput)
+	DeleteVpnGatewayRequest(*ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput)
 
 	DeleteVpnGateway(*ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error)
 
-	DeregisterImageRequest(*ec2.DeregisterImageInput) (*service.Request, *ec2.DeregisterImageOutput)
+	DeregisterImageRequest(*ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput)
 
 	DeregisterImage(*ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error)
 
-	DescribeAccountAttributesRequest(*ec2.DescribeAccountAttributesInput) (*service.Request, *ec2.DescribeAccountAttributesOutput)
+	DescribeAccountAttributesRequest(*ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput)
 
 	DescribeAccountAttributes(*ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error)
 
-	DescribeAddressesRequest(*ec2.DescribeAddressesInput) (*service.Request, *ec2.DescribeAddressesOutput)
+	DescribeAddressesRequest(*ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput)
 
 	DescribeAddresses(*ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error)
 
-	DescribeAvailabilityZonesRequest(*ec2.DescribeAvailabilityZonesInput) (*service.Request, *ec2.DescribeAvailabilityZonesOutput)
+	DescribeAvailabilityZonesRequest(*ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput)
 
 	DescribeAvailabilityZones(*ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error)
 
-	DescribeBundleTasksRequest(*ec2.DescribeBundleTasksInput) (*service.Request, *ec2.DescribeBundleTasksOutput)
+	DescribeBundleTasksRequest(*ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput)
 
 	DescribeBundleTasks(*ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error)
 
-	DescribeClassicLinkInstancesRequest(*ec2.DescribeClassicLinkInstancesInput) (*service.Request, *ec2.DescribeClassicLinkInstancesOutput)
+	DescribeClassicLinkInstancesRequest(*ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput)
 
 	DescribeClassicLinkInstances(*ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error)
 
-	DescribeConversionTasksRequest(*ec2.DescribeConversionTasksInput) (*service.Request, *ec2.DescribeConversionTasksOutput)
+	DescribeConversionTasksRequest(*ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput)
 
 	DescribeConversionTasks(*ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error)
 
-	DescribeCustomerGatewaysRequest(*ec2.DescribeCustomerGatewaysInput) (*service.Request, *ec2.DescribeCustomerGatewaysOutput)
+	DescribeCustomerGatewaysRequest(*ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput)
 
 	DescribeCustomerGateways(*ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error)
 
-	DescribeDhcpOptionsRequest(*ec2.DescribeDhcpOptionsInput) (*service.Request, *ec2.DescribeDhcpOptionsOutput)
+	DescribeDhcpOptionsRequest(*ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput)
 
 	DescribeDhcpOptions(*ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error)
 
-	DescribeExportTasksRequest(*ec2.DescribeExportTasksInput) (*service.Request, *ec2.DescribeExportTasksOutput)
+	DescribeExportTasksRequest(*ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput)
 
 	DescribeExportTasks(*ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error)
 
-	DescribeFlowLogsRequest(*ec2.DescribeFlowLogsInput) (*service.Request, *ec2.DescribeFlowLogsOutput)
+	DescribeFlowLogsRequest(*ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput)
 
 	DescribeFlowLogs(*ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error)
 
-	DescribeImageAttributeRequest(*ec2.DescribeImageAttributeInput) (*service.Request, *ec2.DescribeImageAttributeOutput)
+	DescribeImageAttributeRequest(*ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput)
 
 	DescribeImageAttribute(*ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error)
 
-	DescribeImagesRequest(*ec2.DescribeImagesInput) (*service.Request, *ec2.DescribeImagesOutput)
+	DescribeImagesRequest(*ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput)
 
 	DescribeImages(*ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error)
 
-	DescribeImportImageTasksRequest(*ec2.DescribeImportImageTasksInput) (*service.Request, *ec2.DescribeImportImageTasksOutput)
+	DescribeImportImageTasksRequest(*ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput)
 
 	DescribeImportImageTasks(*ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error)
 
-	DescribeImportSnapshotTasksRequest(*ec2.DescribeImportSnapshotTasksInput) (*service.Request, *ec2.DescribeImportSnapshotTasksOutput)
+	DescribeImportSnapshotTasksRequest(*ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput)
 
 	DescribeImportSnapshotTasks(*ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error)
 
-	DescribeInstanceAttributeRequest(*ec2.DescribeInstanceAttributeInput) (*service.Request, *ec2.DescribeInstanceAttributeOutput)
+	DescribeInstanceAttributeRequest(*ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput)
 
 	DescribeInstanceAttribute(*ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error)
 
-	DescribeInstanceStatusRequest(*ec2.DescribeInstanceStatusInput) (*service.Request, *ec2.DescribeInstanceStatusOutput)
+	DescribeInstanceStatusRequest(*ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput)
 
 	DescribeInstanceStatus(*ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error)
 
 	DescribeInstanceStatusPages(*ec2.DescribeInstanceStatusInput, func(*ec2.DescribeInstanceStatusOutput, bool) bool) error
 
-	DescribeInstancesRequest(*ec2.DescribeInstancesInput) (*service.Request, *ec2.DescribeInstancesOutput)
+	DescribeInstancesRequest(*ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput)
 
 	DescribeInstances(*ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error)
 
 	DescribeInstancesPages(*ec2.DescribeInstancesInput, func(*ec2.DescribeInstancesOutput, bool) bool) error
 
-	DescribeInternetGatewaysRequest(*ec2.DescribeInternetGatewaysInput) (*service.Request, *ec2.DescribeInternetGatewaysOutput)
+	DescribeInternetGatewaysRequest(*ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput)
 
 	DescribeInternetGateways(*ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error)
 
-	DescribeKeyPairsRequest(*ec2.DescribeKeyPairsInput) (*service.Request, *ec2.DescribeKeyPairsOutput)
+	DescribeKeyPairsRequest(*ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput)
 
 	DescribeKeyPairs(*ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error)
 
-	DescribeMovingAddressesRequest(*ec2.DescribeMovingAddressesInput) (*service.Request, *ec2.DescribeMovingAddressesOutput)
+	DescribeMovingAddressesRequest(*ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput)
 
 	DescribeMovingAddresses(*ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error)
 
-	DescribeNetworkAclsRequest(*ec2.DescribeNetworkAclsInput) (*service.Request, *ec2.DescribeNetworkAclsOutput)
+	DescribeNetworkAclsRequest(*ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput)
 
 	DescribeNetworkAcls(*ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error)
 
-	DescribeNetworkInterfaceAttributeRequest(*ec2.DescribeNetworkInterfaceAttributeInput) (*service.Request, *ec2.DescribeNetworkInterfaceAttributeOutput)
+	DescribeNetworkInterfaceAttributeRequest(*ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput)
 
 	DescribeNetworkInterfaceAttribute(*ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error)
 
-	DescribeNetworkInterfacesRequest(*ec2.DescribeNetworkInterfacesInput) (*service.Request, *ec2.DescribeNetworkInterfacesOutput)
+	DescribeNetworkInterfacesRequest(*ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput)
 
 	DescribeNetworkInterfaces(*ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error)
 
-	DescribePlacementGroupsRequest(*ec2.DescribePlacementGroupsInput) (*service.Request, *ec2.DescribePlacementGroupsOutput)
+	DescribePlacementGroupsRequest(*ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput)
 
 	DescribePlacementGroups(*ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error)
 
-	DescribePrefixListsRequest(*ec2.DescribePrefixListsInput) (*service.Request, *ec2.DescribePrefixListsOutput)
+	DescribePrefixListsRequest(*ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput)
 
 	DescribePrefixLists(*ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error)
 
-	DescribeRegionsRequest(*ec2.DescribeRegionsInput) (*service.Request, *ec2.DescribeRegionsOutput)
+	DescribeRegionsRequest(*ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput)
 
 	DescribeRegions(*ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error)
 
-	DescribeReservedInstancesRequest(*ec2.DescribeReservedInstancesInput) (*service.Request, *ec2.DescribeReservedInstancesOutput)
+	DescribeReservedInstancesRequest(*ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput)
 
 	DescribeReservedInstances(*ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error)
 
-	DescribeReservedInstancesListingsRequest(*ec2.DescribeReservedInstancesListingsInput) (*service.Request, *ec2.DescribeReservedInstancesListingsOutput)
+	DescribeReservedInstancesListingsRequest(*ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput)
 
 	DescribeReservedInstancesListings(*ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error)
 
-	DescribeReservedInstancesModificationsRequest(*ec2.DescribeReservedInstancesModificationsInput) (*service.Request, *ec2.DescribeReservedInstancesModificationsOutput)
+	DescribeReservedInstancesModificationsRequest(*ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput)
 
 	DescribeReservedInstancesModifications(*ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error)
 
 	DescribeReservedInstancesModificationsPages(*ec2.DescribeReservedInstancesModificationsInput, func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error
 
-	DescribeReservedInstancesOfferingsRequest(*ec2.DescribeReservedInstancesOfferingsInput) (*service.Request, *ec2.DescribeReservedInstancesOfferingsOutput)
+	DescribeReservedInstancesOfferingsRequest(*ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput)
 
 	DescribeReservedInstancesOfferings(*ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error)
 
 	DescribeReservedInstancesOfferingsPages(*ec2.DescribeReservedInstancesOfferingsInput, func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error
 
-	DescribeRouteTablesRequest(*ec2.DescribeRouteTablesInput) (*service.Request, *ec2.DescribeRouteTablesOutput)
+	DescribeRouteTablesRequest(*ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput)
 
 	DescribeRouteTables(*ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error)
 
-	DescribeSecurityGroupsRequest(*ec2.DescribeSecurityGroupsInput) (*service.Request, *ec2.DescribeSecurityGroupsOutput)
+	DescribeSecurityGroupsRequest(*ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput)
 
 	DescribeSecurityGroups(*ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error)
 
-	DescribeSnapshotAttributeRequest(*ec2.DescribeSnapshotAttributeInput) (*service.Request, *ec2.DescribeSnapshotAttributeOutput)
+	DescribeSnapshotAttributeRequest(*ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput)
 
 	DescribeSnapshotAttribute(*ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error)
 
-	DescribeSnapshotsRequest(*ec2.DescribeSnapshotsInput) (*service.Request, *ec2.DescribeSnapshotsOutput)
+	DescribeSnapshotsRequest(*ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput)
 
 	DescribeSnapshots(*ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error)
 
 	DescribeSnapshotsPages(*ec2.DescribeSnapshotsInput, func(*ec2.DescribeSnapshotsOutput, bool) bool) error
 
-	DescribeSpotDatafeedSubscriptionRequest(*ec2.DescribeSpotDatafeedSubscriptionInput) (*service.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput)
+	DescribeSpotDatafeedSubscriptionRequest(*ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput)
 
 	DescribeSpotDatafeedSubscription(*ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error)
 
-	DescribeSpotFleetInstancesRequest(*ec2.DescribeSpotFleetInstancesInput) (*service.Request, *ec2.DescribeSpotFleetInstancesOutput)
+	DescribeSpotFleetInstancesRequest(*ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput)
 
 	DescribeSpotFleetInstances(*ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error)
 
-	DescribeSpotFleetRequestHistoryRequest(*ec2.DescribeSpotFleetRequestHistoryInput) (*service.Request, *ec2.DescribeSpotFleetRequestHistoryOutput)
+	DescribeSpotFleetRequestHistoryRequest(*ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput)
 
 	DescribeSpotFleetRequestHistory(*ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error)
 
-	DescribeSpotFleetRequestsRequest(*ec2.DescribeSpotFleetRequestsInput) (*service.Request, *ec2.DescribeSpotFleetRequestsOutput)
+	DescribeSpotFleetRequestsRequest(*ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput)
 
 	DescribeSpotFleetRequests(*ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error)
 
-	DescribeSpotInstanceRequestsRequest(*ec2.DescribeSpotInstanceRequestsInput) (*service.Request, *ec2.DescribeSpotInstanceRequestsOutput)
+	DescribeSpotInstanceRequestsRequest(*ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput)
 
 	DescribeSpotInstanceRequests(*ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error)
 
-	DescribeSpotPriceHistoryRequest(*ec2.DescribeSpotPriceHistoryInput) (*service.Request, *ec2.DescribeSpotPriceHistoryOutput)
+	DescribeSpotPriceHistoryRequest(*ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput)
 
 	DescribeSpotPriceHistory(*ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error)
 
 	DescribeSpotPriceHistoryPages(*ec2.DescribeSpotPriceHistoryInput, func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error
 
-	DescribeSubnetsRequest(*ec2.DescribeSubnetsInput) (*service.Request, *ec2.DescribeSubnetsOutput)
+	DescribeSubnetsRequest(*ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput)
 
 	DescribeSubnets(*ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error)
 
-	DescribeTagsRequest(*ec2.DescribeTagsInput) (*service.Request, *ec2.DescribeTagsOutput)
+	DescribeTagsRequest(*ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput)
 
 	DescribeTags(*ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error)
 
-	DescribeVolumeAttributeRequest(*ec2.DescribeVolumeAttributeInput) (*service.Request, *ec2.DescribeVolumeAttributeOutput)
+	DescribeVolumeAttributeRequest(*ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput)
 
 	DescribeVolumeAttribute(*ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error)
 
-	DescribeVolumeStatusRequest(*ec2.DescribeVolumeStatusInput) (*service.Request, *ec2.DescribeVolumeStatusOutput)
+	DescribeVolumeStatusRequest(*ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput)
 
 	DescribeVolumeStatus(*ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error)
 
 	DescribeVolumeStatusPages(*ec2.DescribeVolumeStatusInput, func(*ec2.DescribeVolumeStatusOutput, bool) bool) error
 
-	DescribeVolumesRequest(*ec2.DescribeVolumesInput) (*service.Request, *ec2.DescribeVolumesOutput)
+	DescribeVolumesRequest(*ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput)
 
 	DescribeVolumes(*ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error)
 
 	DescribeVolumesPages(*ec2.DescribeVolumesInput, func(*ec2.DescribeVolumesOutput, bool) bool) error
 
-	DescribeVpcAttributeRequest(*ec2.DescribeVpcAttributeInput) (*service.Request, *ec2.DescribeVpcAttributeOutput)
+	DescribeVpcAttributeRequest(*ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput)
 
 	DescribeVpcAttribute(*ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error)
 
-	DescribeVpcClassicLinkRequest(*ec2.DescribeVpcClassicLinkInput) (*service.Request, *ec2.DescribeVpcClassicLinkOutput)
+	DescribeVpcClassicLinkRequest(*ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput)
 
 	DescribeVpcClassicLink(*ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error)
 
-	DescribeVpcEndpointServicesRequest(*ec2.DescribeVpcEndpointServicesInput) (*service.Request, *ec2.DescribeVpcEndpointServicesOutput)
+	DescribeVpcEndpointServicesRequest(*ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput)
 
 	DescribeVpcEndpointServices(*ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error)
 
-	DescribeVpcEndpointsRequest(*ec2.DescribeVpcEndpointsInput) (*service.Request, *ec2.DescribeVpcEndpointsOutput)
+	DescribeVpcEndpointsRequest(*ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput)
 
 	DescribeVpcEndpoints(*ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error)
 
-	DescribeVpcPeeringConnectionsRequest(*ec2.DescribeVpcPeeringConnectionsInput) (*service.Request, *ec2.DescribeVpcPeeringConnectionsOutput)
+	DescribeVpcPeeringConnectionsRequest(*ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput)
 
 	DescribeVpcPeeringConnections(*ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error)
 
-	DescribeVpcsRequest(*ec2.DescribeVpcsInput) (*service.Request, *ec2.DescribeVpcsOutput)
+	DescribeVpcsRequest(*ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput)
 
 	DescribeVpcs(*ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error)
 
-	DescribeVpnConnectionsRequest(*ec2.DescribeVpnConnectionsInput) (*service.Request, *ec2.DescribeVpnConnectionsOutput)
+	DescribeVpnConnectionsRequest(*ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput)
 
 	DescribeVpnConnections(*ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error)
 
-	DescribeVpnGatewaysRequest(*ec2.DescribeVpnGatewaysInput) (*service.Request, *ec2.DescribeVpnGatewaysOutput)
+	DescribeVpnGatewaysRequest(*ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput)
 
 	DescribeVpnGateways(*ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error)
 
-	DetachClassicLinkVpcRequest(*ec2.DetachClassicLinkVpcInput) (*service.Request, *ec2.DetachClassicLinkVpcOutput)
+	DetachClassicLinkVpcRequest(*ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput)
 
 	DetachClassicLinkVpc(*ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error)
 
-	DetachInternetGatewayRequest(*ec2.DetachInternetGatewayInput) (*service.Request, *ec2.DetachInternetGatewayOutput)
+	DetachInternetGatewayRequest(*ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput)
 
 	DetachInternetGateway(*ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error)
 
-	DetachNetworkInterfaceRequest(*ec2.DetachNetworkInterfaceInput) (*service.Request, *ec2.DetachNetworkInterfaceOutput)
+	DetachNetworkInterfaceRequest(*ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput)
 
 	DetachNetworkInterface(*ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error)
 
-	DetachVolumeRequest(*ec2.DetachVolumeInput) (*service.Request, *ec2.VolumeAttachment)
+	DetachVolumeRequest(*ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment)
 
 	DetachVolume(*ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error)
 
-	DetachVpnGatewayRequest(*ec2.DetachVpnGatewayInput) (*service.Request, *ec2.DetachVpnGatewayOutput)
+	DetachVpnGatewayRequest(*ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput)
 
 	DetachVpnGateway(*ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error)
 
-	DisableVgwRoutePropagationRequest(*ec2.DisableVgwRoutePropagationInput) (*service.Request, *ec2.DisableVgwRoutePropagationOutput)
+	DisableVgwRoutePropagationRequest(*ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput)
 
 	DisableVgwRoutePropagation(*ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error)
 
-	DisableVpcClassicLinkRequest(*ec2.DisableVpcClassicLinkInput) (*service.Request, *ec2.DisableVpcClassicLinkOutput)
+	DisableVpcClassicLinkRequest(*ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput)
 
 	DisableVpcClassicLink(*ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error)
 
-	DisassociateAddressRequest(*ec2.DisassociateAddressInput) (*service.Request, *ec2.DisassociateAddressOutput)
+	DisassociateAddressRequest(*ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput)
 
 	DisassociateAddress(*ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error)
 
-	DisassociateRouteTableRequest(*ec2.DisassociateRouteTableInput) (*service.Request, *ec2.DisassociateRouteTableOutput)
+	DisassociateRouteTableRequest(*ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput)
 
 	DisassociateRouteTable(*ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error)
 
-	EnableVgwRoutePropagationRequest(*ec2.EnableVgwRoutePropagationInput) (*service.Request, *ec2.EnableVgwRoutePropagationOutput)
+	EnableVgwRoutePropagationRequest(*ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput)
 
 	EnableVgwRoutePropagation(*ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error)
 
-	EnableVolumeIORequest(*ec2.EnableVolumeIOInput) (*service.Request, *ec2.EnableVolumeIOOutput)
+	EnableVolumeIORequest(*ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput)
 
 	EnableVolumeIO(*ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error)
 
-	EnableVpcClassicLinkRequest(*ec2.EnableVpcClassicLinkInput) (*service.Request, *ec2.EnableVpcClassicLinkOutput)
+	EnableVpcClassicLinkRequest(*ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput)
 
 	EnableVpcClassicLink(*ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error)
 
-	GetConsoleOutputRequest(*ec2.GetConsoleOutputInput) (*service.Request, *ec2.GetConsoleOutputOutput)
+	GetConsoleOutputRequest(*ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput)
 
 	GetConsoleOutput(*ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error)
 
-	GetPasswordDataRequest(*ec2.GetPasswordDataInput) (*service.Request, *ec2.GetPasswordDataOutput)
+	GetPasswordDataRequest(*ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput)
 
 	GetPasswordData(*ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error)
 
-	ImportImageRequest(*ec2.ImportImageInput) (*service.Request, *ec2.ImportImageOutput)
+	ImportImageRequest(*ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput)
 
 	ImportImage(*ec2.ImportImageInput) (*ec2.ImportImageOutput, error)
 
-	ImportInstanceRequest(*ec2.ImportInstanceInput) (*service.Request, *ec2.ImportInstanceOutput)
+	ImportInstanceRequest(*ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput)
 
 	ImportInstance(*ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error)
 
-	ImportKeyPairRequest(*ec2.ImportKeyPairInput) (*service.Request, *ec2.ImportKeyPairOutput)
+	ImportKeyPairRequest(*ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput)
 
 	ImportKeyPair(*ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error)
 
-	ImportSnapshotRequest(*ec2.ImportSnapshotInput) (*service.Request, *ec2.ImportSnapshotOutput)
+	ImportSnapshotRequest(*ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput)
 
 	ImportSnapshot(*ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error)
 
-	ImportVolumeRequest(*ec2.ImportVolumeInput) (*service.Request, *ec2.ImportVolumeOutput)
+	ImportVolumeRequest(*ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput)
 
 	ImportVolume(*ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error)
 
-	ModifyImageAttributeRequest(*ec2.ModifyImageAttributeInput) (*service.Request, *ec2.ModifyImageAttributeOutput)
+	ModifyImageAttributeRequest(*ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput)
 
 	ModifyImageAttribute(*ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error)
 
-	ModifyInstanceAttributeRequest(*ec2.ModifyInstanceAttributeInput) (*service.Request, *ec2.ModifyInstanceAttributeOutput)
+	ModifyInstanceAttributeRequest(*ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput)
 
 	ModifyInstanceAttribute(*ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error)
 
-	ModifyNetworkInterfaceAttributeRequest(*ec2.ModifyNetworkInterfaceAttributeInput) (*service.Request, *ec2.ModifyNetworkInterfaceAttributeOutput)
+	ModifyNetworkInterfaceAttributeRequest(*ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput)
 
 	ModifyNetworkInterfaceAttribute(*ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error)
 
-	ModifyReservedInstancesRequest(*ec2.ModifyReservedInstancesInput) (*service.Request, *ec2.ModifyReservedInstancesOutput)
+	ModifyReservedInstancesRequest(*ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput)
 
 	ModifyReservedInstances(*ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error)
 
-	ModifySnapshotAttributeRequest(*ec2.ModifySnapshotAttributeInput) (*service.Request, *ec2.ModifySnapshotAttributeOutput)
+	ModifySnapshotAttributeRequest(*ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput)
 
 	ModifySnapshotAttribute(*ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error)
 
-	ModifySubnetAttributeRequest(*ec2.ModifySubnetAttributeInput) (*service.Request, *ec2.ModifySubnetAttributeOutput)
+	ModifySubnetAttributeRequest(*ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput)
 
 	ModifySubnetAttribute(*ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error)
 
-	ModifyVolumeAttributeRequest(*ec2.ModifyVolumeAttributeInput) (*service.Request, *ec2.ModifyVolumeAttributeOutput)
+	ModifyVolumeAttributeRequest(*ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput)
 
 	ModifyVolumeAttribute(*ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error)
 
-	ModifyVpcAttributeRequest(*ec2.ModifyVpcAttributeInput) (*service.Request, *ec2.ModifyVpcAttributeOutput)
+	ModifyVpcAttributeRequest(*ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput)
 
 	ModifyVpcAttribute(*ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error)
 
-	ModifyVpcEndpointRequest(*ec2.ModifyVpcEndpointInput) (*service.Request, *ec2.ModifyVpcEndpointOutput)
+	ModifyVpcEndpointRequest(*ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput)
 
 	ModifyVpcEndpoint(*ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error)
 
-	MonitorInstancesRequest(*ec2.MonitorInstancesInput) (*service.Request, *ec2.MonitorInstancesOutput)
+	MonitorInstancesRequest(*ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput)
 
 	MonitorInstances(*ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error)
 
-	MoveAddressToVpcRequest(*ec2.MoveAddressToVpcInput) (*service.Request, *ec2.MoveAddressToVpcOutput)
+	MoveAddressToVpcRequest(*ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput)
 
 	MoveAddressToVpc(*ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error)
 
-	PurchaseReservedInstancesOfferingRequest(*ec2.PurchaseReservedInstancesOfferingInput) (*service.Request, *ec2.PurchaseReservedInstancesOfferingOutput)
+	PurchaseReservedInstancesOfferingRequest(*ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput)
 
 	PurchaseReservedInstancesOffering(*ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error)
 
-	RebootInstancesRequest(*ec2.RebootInstancesInput) (*service.Request, *ec2.RebootInstancesOutput)
+	RebootInstancesRequest(*ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput)
 
 	RebootInstances(*ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error)
 
-	RegisterImageRequest(*ec2.RegisterImageInput) (*service.Request, *ec2.RegisterImageOutput)
+	RegisterImageRequest(*ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput)
 
 	RegisterImage(*ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error)
 
-	RejectVpcPeeringConnectionRequest(*ec2.RejectVpcPeeringConnectionInput) (*service.Request, *ec2.RejectVpcPeeringConnectionOutput)
+	RejectVpcPeeringConnectionRequest(*ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput)
 
 	RejectVpcPeeringConnection(*ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error)
 
-	ReleaseAddressRequest(*ec2.ReleaseAddressInput) (*service.Request, *ec2.ReleaseAddressOutput)
+	ReleaseAddressRequest(*ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput)
 
 	ReleaseAddress(*ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error)
 
-	ReplaceNetworkAclAssociationRequest(*ec2.ReplaceNetworkAclAssociationInput) (*service.Request, *ec2.ReplaceNetworkAclAssociationOutput)
+	ReplaceNetworkAclAssociationRequest(*ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput)
 
 	ReplaceNetworkAclAssociation(*ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error)
 
-	ReplaceNetworkAclEntryRequest(*ec2.ReplaceNetworkAclEntryInput) (*service.Request, *ec2.ReplaceNetworkAclEntryOutput)
+	ReplaceNetworkAclEntryRequest(*ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput)
 
 	ReplaceNetworkAclEntry(*ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error)
 
-	ReplaceRouteRequest(*ec2.ReplaceRouteInput) (*service.Request, *ec2.ReplaceRouteOutput)
+	ReplaceRouteRequest(*ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput)
 
 	ReplaceRoute(*ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error)
 
-	ReplaceRouteTableAssociationRequest(*ec2.ReplaceRouteTableAssociationInput) (*service.Request, *ec2.ReplaceRouteTableAssociationOutput)
+	ReplaceRouteTableAssociationRequest(*ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput)
 
 	ReplaceRouteTableAssociation(*ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error)
 
-	ReportInstanceStatusRequest(*ec2.ReportInstanceStatusInput) (*service.Request, *ec2.ReportInstanceStatusOutput)
+	ReportInstanceStatusRequest(*ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput)
 
 	ReportInstanceStatus(*ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error)
 
-	RequestSpotFleetRequest(*ec2.RequestSpotFleetInput) (*service.Request, *ec2.RequestSpotFleetOutput)
+	RequestSpotFleetRequest(*ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput)
 
 	RequestSpotFleet(*ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error)
 
-	RequestSpotInstancesRequest(*ec2.RequestSpotInstancesInput) (*service.Request, *ec2.RequestSpotInstancesOutput)
+	RequestSpotInstancesRequest(*ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput)
 
 	RequestSpotInstances(*ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error)
 
-	ResetImageAttributeRequest(*ec2.ResetImageAttributeInput) (*service.Request, *ec2.ResetImageAttributeOutput)
+	ResetImageAttributeRequest(*ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput)
 
 	ResetImageAttribute(*ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error)
 
-	ResetInstanceAttributeRequest(*ec2.ResetInstanceAttributeInput) (*service.Request, *ec2.ResetInstanceAttributeOutput)
+	ResetInstanceAttributeRequest(*ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput)
 
 	ResetInstanceAttribute(*ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error)
 
-	ResetNetworkInterfaceAttributeRequest(*ec2.ResetNetworkInterfaceAttributeInput) (*service.Request, *ec2.ResetNetworkInterfaceAttributeOutput)
+	ResetNetworkInterfaceAttributeRequest(*ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput)
 
 	ResetNetworkInterfaceAttribute(*ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error)
 
-	ResetSnapshotAttributeRequest(*ec2.ResetSnapshotAttributeInput) (*service.Request, *ec2.ResetSnapshotAttributeOutput)
+	ResetSnapshotAttributeRequest(*ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput)
 
 	ResetSnapshotAttribute(*ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error)
 
-	RestoreAddressToClassicRequest(*ec2.RestoreAddressToClassicInput) (*service.Request, *ec2.RestoreAddressToClassicOutput)
+	RestoreAddressToClassicRequest(*ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput)
 
 	RestoreAddressToClassic(*ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error)
 
-	RevokeSecurityGroupEgressRequest(*ec2.RevokeSecurityGroupEgressInput) (*service.Request, *ec2.RevokeSecurityGroupEgressOutput)
+	RevokeSecurityGroupEgressRequest(*ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput)
 
 	RevokeSecurityGroupEgress(*ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error)
 
-	RevokeSecurityGroupIngressRequest(*ec2.RevokeSecurityGroupIngressInput) (*service.Request, *ec2.RevokeSecurityGroupIngressOutput)
+	RevokeSecurityGroupIngressRequest(*ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput)
 
 	RevokeSecurityGroupIngress(*ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error)
 
-	RunInstancesRequest(*ec2.RunInstancesInput) (*service.Request, *ec2.Reservation)
+	RunInstancesRequest(*ec2.RunInstancesInput) (*request.Request, *ec2.Reservation)
 
 	RunInstances(*ec2.RunInstancesInput) (*ec2.Reservation, error)
 
-	StartInstancesRequest(*ec2.StartInstancesInput) (*service.Request, *ec2.StartInstancesOutput)
+	StartInstancesRequest(*ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput)
 
 	StartInstances(*ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error)
 
-	StopInstancesRequest(*ec2.StopInstancesInput) (*service.Request, *ec2.StopInstancesOutput)
+	StopInstancesRequest(*ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput)
 
 	StopInstances(*ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error)
 
-	TerminateInstancesRequest(*ec2.TerminateInstancesInput) (*service.Request, *ec2.TerminateInstancesOutput)
+	TerminateInstancesRequest(*ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput)
 
 	TerminateInstances(*ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error)
 
-	UnassignPrivateIpAddressesRequest(*ec2.UnassignPrivateIpAddressesInput) (*service.Request, *ec2.UnassignPrivateIpAddressesOutput)
+	UnassignPrivateIpAddressesRequest(*ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput)
 
 	UnassignPrivateIpAddresses(*ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error)
 
-	UnmonitorInstancesRequest(*ec2.UnmonitorInstancesInput) (*service.Request, *ec2.UnmonitorInstancesOutput)
+	UnmonitorInstancesRequest(*ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput)
 
 	UnmonitorInstances(*ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error)
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface_test.go

@@ -1,15 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package ec2iface_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestInterface(t *testing.T) {
-	assert.Implements(t, (*ec2iface.EC2API)(nil), ec2.New(nil))
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/ec2/service.go

@@ -5,7 +5,9 @@ package ec2
 import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/defaults"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
 	"github.com/aws/aws-sdk-go/internal/signer/v4"
 )
@@ -22,14 +24,16 @@ type EC2 struct {
 var initService func(*service.Service)
 
 // Used for custom request initialization logic
-var initRequest func(*service.Request)
+var initRequest func(*request.Request)
 
 // New returns a new EC2 client.
 func New(config *aws.Config) *EC2 {
 	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
+		ServiceInfo: serviceinfo.ServiceInfo{
-		ServiceName: "ec2",
+			Config:      defaults.DefaultConfig.Merge(config),
-		APIVersion:  "2015-04-15",
+			ServiceName: "ec2",
+			APIVersion:  "2015-04-15",
+		},
 	}
 	service.Initialize()
 
@@ -50,8 +54,8 @@ func New(config *aws.Config) *EC2 {
 
 // newRequest creates a new request for a EC2 operation and runs any
 // custom request initialization.
-func (c *EC2) newRequest(op *service.Operation, params, data interface{}) *service.Request {
+func (c *EC2) newRequest(op *request.Operation, params, data interface{}) *request.Request {
-	req := service.NewRequest(c.Service, op, params, data)
+	req := c.NewRequest(op, params, data)
 
 	// Run custom request initialization if present
 	if initRequest != nil {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/iam/iamiface/interface.go

@@ -4,489 +4,505 @@
 package iamiface
 
 import (
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/iam"
 )
 
 // IAMAPI is the interface type for iam.IAM.
 type IAMAPI interface {
-	AddClientIDToOpenIDConnectProviderRequest(*iam.AddClientIDToOpenIDConnectProviderInput) (*service.Request, *iam.AddClientIDToOpenIDConnectProviderOutput)
+	AddClientIDToOpenIDConnectProviderRequest(*iam.AddClientIDToOpenIDConnectProviderInput) (*request.Request, *iam.AddClientIDToOpenIDConnectProviderOutput)
 
 	AddClientIDToOpenIDConnectProvider(*iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error)
 
-	AddRoleToInstanceProfileRequest(*iam.AddRoleToInstanceProfileInput) (*service.Request, *iam.AddRoleToInstanceProfileOutput)
+	AddRoleToInstanceProfileRequest(*iam.AddRoleToInstanceProfileInput) (*request.Request, *iam.AddRoleToInstanceProfileOutput)
 
 	AddRoleToInstanceProfile(*iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error)
 
-	AddUserToGroupRequest(*iam.AddUserToGroupInput) (*service.Request, *iam.AddUserToGroupOutput)
+	AddUserToGroupRequest(*iam.AddUserToGroupInput) (*request.Request, *iam.AddUserToGroupOutput)
 
 	AddUserToGroup(*iam.AddUserToGroupInput) (*iam.AddUserToGroupOutput, error)
 
-	AttachGroupPolicyRequest(*iam.AttachGroupPolicyInput) (*service.Request, *iam.AttachGroupPolicyOutput)
+	AttachGroupPolicyRequest(*iam.AttachGroupPolicyInput) (*request.Request, *iam.AttachGroupPolicyOutput)
 
 	AttachGroupPolicy(*iam.AttachGroupPolicyInput) (*iam.AttachGroupPolicyOutput, error)
 
-	AttachRolePolicyRequest(*iam.AttachRolePolicyInput) (*service.Request, *iam.AttachRolePolicyOutput)
+	AttachRolePolicyRequest(*iam.AttachRolePolicyInput) (*request.Request, *iam.AttachRolePolicyOutput)
 
 	AttachRolePolicy(*iam.AttachRolePolicyInput) (*iam.AttachRolePolicyOutput, error)
 
-	AttachUserPolicyRequest(*iam.AttachUserPolicyInput) (*service.Request, *iam.AttachUserPolicyOutput)
+	AttachUserPolicyRequest(*iam.AttachUserPolicyInput) (*request.Request, *iam.AttachUserPolicyOutput)
 
 	AttachUserPolicy(*iam.AttachUserPolicyInput) (*iam.AttachUserPolicyOutput, error)
 
-	ChangePasswordRequest(*iam.ChangePasswordInput) (*service.Request, *iam.ChangePasswordOutput)
+	ChangePasswordRequest(*iam.ChangePasswordInput) (*request.Request, *iam.ChangePasswordOutput)
 
 	ChangePassword(*iam.ChangePasswordInput) (*iam.ChangePasswordOutput, error)
 
-	CreateAccessKeyRequest(*iam.CreateAccessKeyInput) (*service.Request, *iam.CreateAccessKeyOutput)
+	CreateAccessKeyRequest(*iam.CreateAccessKeyInput) (*request.Request, *iam.CreateAccessKeyOutput)
 
 	CreateAccessKey(*iam.CreateAccessKeyInput) (*iam.CreateAccessKeyOutput, error)
 
-	CreateAccountAliasRequest(*iam.CreateAccountAliasInput) (*service.Request, *iam.CreateAccountAliasOutput)
+	CreateAccountAliasRequest(*iam.CreateAccountAliasInput) (*request.Request, *iam.CreateAccountAliasOutput)
 
 	CreateAccountAlias(*iam.CreateAccountAliasInput) (*iam.CreateAccountAliasOutput, error)
 
-	CreateGroupRequest(*iam.CreateGroupInput) (*service.Request, *iam.CreateGroupOutput)
+	CreateGroupRequest(*iam.CreateGroupInput) (*request.Request, *iam.CreateGroupOutput)
 
 	CreateGroup(*iam.CreateGroupInput) (*iam.CreateGroupOutput, error)
 
-	CreateInstanceProfileRequest(*iam.CreateInstanceProfileInput) (*service.Request, *iam.CreateInstanceProfileOutput)
+	CreateInstanceProfileRequest(*iam.CreateInstanceProfileInput) (*request.Request, *iam.CreateInstanceProfileOutput)
 
 	CreateInstanceProfile(*iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error)
 
-	CreateLoginProfileRequest(*iam.CreateLoginProfileInput) (*service.Request, *iam.CreateLoginProfileOutput)
+	CreateLoginProfileRequest(*iam.CreateLoginProfileInput) (*request.Request, *iam.CreateLoginProfileOutput)
 
 	CreateLoginProfile(*iam.CreateLoginProfileInput) (*iam.CreateLoginProfileOutput, error)
 
-	CreateOpenIDConnectProviderRequest(*iam.CreateOpenIDConnectProviderInput) (*service.Request, *iam.CreateOpenIDConnectProviderOutput)
+	CreateOpenIDConnectProviderRequest(*iam.CreateOpenIDConnectProviderInput) (*request.Request, *iam.CreateOpenIDConnectProviderOutput)
 
 	CreateOpenIDConnectProvider(*iam.CreateOpenIDConnectProviderInput) (*iam.CreateOpenIDConnectProviderOutput, error)
 
-	CreatePolicyRequest(*iam.CreatePolicyInput) (*service.Request, *iam.CreatePolicyOutput)
+	CreatePolicyRequest(*iam.CreatePolicyInput) (*request.Request, *iam.CreatePolicyOutput)
 
 	CreatePolicy(*iam.CreatePolicyInput) (*iam.CreatePolicyOutput, error)
 
-	CreatePolicyVersionRequest(*iam.CreatePolicyVersionInput) (*service.Request, *iam.CreatePolicyVersionOutput)
+	CreatePolicyVersionRequest(*iam.CreatePolicyVersionInput) (*request.Request, *iam.CreatePolicyVersionOutput)
 
 	CreatePolicyVersion(*iam.CreatePolicyVersionInput) (*iam.CreatePolicyVersionOutput, error)
 
-	CreateRoleRequest(*iam.CreateRoleInput) (*service.Request, *iam.CreateRoleOutput)
+	CreateRoleRequest(*iam.CreateRoleInput) (*request.Request, *iam.CreateRoleOutput)
 
 	CreateRole(*iam.CreateRoleInput) (*iam.CreateRoleOutput, error)
 
-	CreateSAMLProviderRequest(*iam.CreateSAMLProviderInput) (*service.Request, *iam.CreateSAMLProviderOutput)
+	CreateSAMLProviderRequest(*iam.CreateSAMLProviderInput) (*request.Request, *iam.CreateSAMLProviderOutput)
 
 	CreateSAMLProvider(*iam.CreateSAMLProviderInput) (*iam.CreateSAMLProviderOutput, error)
 
-	CreateUserRequest(*iam.CreateUserInput) (*service.Request, *iam.CreateUserOutput)
+	CreateUserRequest(*iam.CreateUserInput) (*request.Request, *iam.CreateUserOutput)
 
 	CreateUser(*iam.CreateUserInput) (*iam.CreateUserOutput, error)
 
-	CreateVirtualMFADeviceRequest(*iam.CreateVirtualMFADeviceInput) (*service.Request, *iam.CreateVirtualMFADeviceOutput)
+	CreateVirtualMFADeviceRequest(*iam.CreateVirtualMFADeviceInput) (*request.Request, *iam.CreateVirtualMFADeviceOutput)
 
 	CreateVirtualMFADevice(*iam.CreateVirtualMFADeviceInput) (*iam.CreateVirtualMFADeviceOutput, error)
 
-	DeactivateMFADeviceRequest(*iam.DeactivateMFADeviceInput) (*service.Request, *iam.DeactivateMFADeviceOutput)
+	DeactivateMFADeviceRequest(*iam.DeactivateMFADeviceInput) (*request.Request, *iam.DeactivateMFADeviceOutput)
 
 	DeactivateMFADevice(*iam.DeactivateMFADeviceInput) (*iam.DeactivateMFADeviceOutput, error)
 
-	DeleteAccessKeyRequest(*iam.DeleteAccessKeyInput) (*service.Request, *iam.DeleteAccessKeyOutput)
+	DeleteAccessKeyRequest(*iam.DeleteAccessKeyInput) (*request.Request, *iam.DeleteAccessKeyOutput)
 
 	DeleteAccessKey(*iam.DeleteAccessKeyInput) (*iam.DeleteAccessKeyOutput, error)
 
-	DeleteAccountAliasRequest(*iam.DeleteAccountAliasInput) (*service.Request, *iam.DeleteAccountAliasOutput)
+	DeleteAccountAliasRequest(*iam.DeleteAccountAliasInput) (*request.Request, *iam.DeleteAccountAliasOutput)
 
 	DeleteAccountAlias(*iam.DeleteAccountAliasInput) (*iam.DeleteAccountAliasOutput, error)
 
-	DeleteAccountPasswordPolicyRequest(*iam.DeleteAccountPasswordPolicyInput) (*service.Request, *iam.DeleteAccountPasswordPolicyOutput)
+	DeleteAccountPasswordPolicyRequest(*iam.DeleteAccountPasswordPolicyInput) (*request.Request, *iam.DeleteAccountPasswordPolicyOutput)
 
 	DeleteAccountPasswordPolicy(*iam.DeleteAccountPasswordPolicyInput) (*iam.DeleteAccountPasswordPolicyOutput, error)
 
-	DeleteGroupRequest(*iam.DeleteGroupInput) (*service.Request, *iam.DeleteGroupOutput)
+	DeleteGroupRequest(*iam.DeleteGroupInput) (*request.Request, *iam.DeleteGroupOutput)
 
 	DeleteGroup(*iam.DeleteGroupInput) (*iam.DeleteGroupOutput, error)
 
-	DeleteGroupPolicyRequest(*iam.DeleteGroupPolicyInput) (*service.Request, *iam.DeleteGroupPolicyOutput)
+	DeleteGroupPolicyRequest(*iam.DeleteGroupPolicyInput) (*request.Request, *iam.DeleteGroupPolicyOutput)
 
 	DeleteGroupPolicy(*iam.DeleteGroupPolicyInput) (*iam.DeleteGroupPolicyOutput, error)
 
-	DeleteInstanceProfileRequest(*iam.DeleteInstanceProfileInput) (*service.Request, *iam.DeleteInstanceProfileOutput)
+	DeleteInstanceProfileRequest(*iam.DeleteInstanceProfileInput) (*request.Request, *iam.DeleteInstanceProfileOutput)
 
 	DeleteInstanceProfile(*iam.DeleteInstanceProfileInput) (*iam.DeleteInstanceProfileOutput, error)
 
-	DeleteLoginProfileRequest(*iam.DeleteLoginProfileInput) (*service.Request, *iam.DeleteLoginProfileOutput)
+	DeleteLoginProfileRequest(*iam.DeleteLoginProfileInput) (*request.Request, *iam.DeleteLoginProfileOutput)
 
 	DeleteLoginProfile(*iam.DeleteLoginProfileInput) (*iam.DeleteLoginProfileOutput, error)
 
-	DeleteOpenIDConnectProviderRequest(*iam.DeleteOpenIDConnectProviderInput) (*service.Request, *iam.DeleteOpenIDConnectProviderOutput)
+	DeleteOpenIDConnectProviderRequest(*iam.DeleteOpenIDConnectProviderInput) (*request.Request, *iam.DeleteOpenIDConnectProviderOutput)
 
 	DeleteOpenIDConnectProvider(*iam.DeleteOpenIDConnectProviderInput) (*iam.DeleteOpenIDConnectProviderOutput, error)
 
-	DeletePolicyRequest(*iam.DeletePolicyInput) (*service.Request, *iam.DeletePolicyOutput)
+	DeletePolicyRequest(*iam.DeletePolicyInput) (*request.Request, *iam.DeletePolicyOutput)
 
 	DeletePolicy(*iam.DeletePolicyInput) (*iam.DeletePolicyOutput, error)
 
-	DeletePolicyVersionRequest(*iam.DeletePolicyVersionInput) (*service.Request, *iam.DeletePolicyVersionOutput)
+	DeletePolicyVersionRequest(*iam.DeletePolicyVersionInput) (*request.Request, *iam.DeletePolicyVersionOutput)
 
 	DeletePolicyVersion(*iam.DeletePolicyVersionInput) (*iam.DeletePolicyVersionOutput, error)
 
-	DeleteRoleRequest(*iam.DeleteRoleInput) (*service.Request, *iam.DeleteRoleOutput)
+	DeleteRoleRequest(*iam.DeleteRoleInput) (*request.Request, *iam.DeleteRoleOutput)
 
 	DeleteRole(*iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error)
 
-	DeleteRolePolicyRequest(*iam.DeleteRolePolicyInput) (*service.Request, *iam.DeleteRolePolicyOutput)
+	DeleteRolePolicyRequest(*iam.DeleteRolePolicyInput) (*request.Request, *iam.DeleteRolePolicyOutput)
 
 	DeleteRolePolicy(*iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error)
 
-	DeleteSAMLProviderRequest(*iam.DeleteSAMLProviderInput) (*service.Request, *iam.DeleteSAMLProviderOutput)
+	DeleteSAMLProviderRequest(*iam.DeleteSAMLProviderInput) (*request.Request, *iam.DeleteSAMLProviderOutput)
 
 	DeleteSAMLProvider(*iam.DeleteSAMLProviderInput) (*iam.DeleteSAMLProviderOutput, error)
 
-	DeleteSSHPublicKeyRequest(*iam.DeleteSSHPublicKeyInput) (*service.Request, *iam.DeleteSSHPublicKeyOutput)
+	DeleteSSHPublicKeyRequest(*iam.DeleteSSHPublicKeyInput) (*request.Request, *iam.DeleteSSHPublicKeyOutput)
 
 	DeleteSSHPublicKey(*iam.DeleteSSHPublicKeyInput) (*iam.DeleteSSHPublicKeyOutput, error)
 
-	DeleteServerCertificateRequest(*iam.DeleteServerCertificateInput) (*service.Request, *iam.DeleteServerCertificateOutput)
+	DeleteServerCertificateRequest(*iam.DeleteServerCertificateInput) (*request.Request, *iam.DeleteServerCertificateOutput)
 
 	DeleteServerCertificate(*iam.DeleteServerCertificateInput) (*iam.DeleteServerCertificateOutput, error)
 
-	DeleteSigningCertificateRequest(*iam.DeleteSigningCertificateInput) (*service.Request, *iam.DeleteSigningCertificateOutput)
+	DeleteSigningCertificateRequest(*iam.DeleteSigningCertificateInput) (*request.Request, *iam.DeleteSigningCertificateOutput)
 
 	DeleteSigningCertificate(*iam.DeleteSigningCertificateInput) (*iam.DeleteSigningCertificateOutput, error)
 
-	DeleteUserRequest(*iam.DeleteUserInput) (*service.Request, *iam.DeleteUserOutput)
+	DeleteUserRequest(*iam.DeleteUserInput) (*request.Request, *iam.DeleteUserOutput)
 
 	DeleteUser(*iam.DeleteUserInput) (*iam.DeleteUserOutput, error)
 
-	DeleteUserPolicyRequest(*iam.DeleteUserPolicyInput) (*service.Request, *iam.DeleteUserPolicyOutput)
+	DeleteUserPolicyRequest(*iam.DeleteUserPolicyInput) (*request.Request, *iam.DeleteUserPolicyOutput)
 
 	DeleteUserPolicy(*iam.DeleteUserPolicyInput) (*iam.DeleteUserPolicyOutput, error)
 
-	DeleteVirtualMFADeviceRequest(*iam.DeleteVirtualMFADeviceInput) (*service.Request, *iam.DeleteVirtualMFADeviceOutput)
+	DeleteVirtualMFADeviceRequest(*iam.DeleteVirtualMFADeviceInput) (*request.Request, *iam.DeleteVirtualMFADeviceOutput)
 
 	DeleteVirtualMFADevice(*iam.DeleteVirtualMFADeviceInput) (*iam.DeleteVirtualMFADeviceOutput, error)
 
-	DetachGroupPolicyRequest(*iam.DetachGroupPolicyInput) (*service.Request, *iam.DetachGroupPolicyOutput)
+	DetachGroupPolicyRequest(*iam.DetachGroupPolicyInput) (*request.Request, *iam.DetachGroupPolicyOutput)
 
 	DetachGroupPolicy(*iam.DetachGroupPolicyInput) (*iam.DetachGroupPolicyOutput, error)
 
-	DetachRolePolicyRequest(*iam.DetachRolePolicyInput) (*service.Request, *iam.DetachRolePolicyOutput)
+	DetachRolePolicyRequest(*iam.DetachRolePolicyInput) (*request.Request, *iam.DetachRolePolicyOutput)
 
 	DetachRolePolicy(*iam.DetachRolePolicyInput) (*iam.DetachRolePolicyOutput, error)
 
-	DetachUserPolicyRequest(*iam.DetachUserPolicyInput) (*service.Request, *iam.DetachUserPolicyOutput)
+	DetachUserPolicyRequest(*iam.DetachUserPolicyInput) (*request.Request, *iam.DetachUserPolicyOutput)
 
 	DetachUserPolicy(*iam.DetachUserPolicyInput) (*iam.DetachUserPolicyOutput, error)
 
-	EnableMFADeviceRequest(*iam.EnableMFADeviceInput) (*service.Request, *iam.EnableMFADeviceOutput)
+	EnableMFADeviceRequest(*iam.EnableMFADeviceInput) (*request.Request, *iam.EnableMFADeviceOutput)
 
 	EnableMFADevice(*iam.EnableMFADeviceInput) (*iam.EnableMFADeviceOutput, error)
 
-	GenerateCredentialReportRequest(*iam.GenerateCredentialReportInput) (*service.Request, *iam.GenerateCredentialReportOutput)
+	GenerateCredentialReportRequest(*iam.GenerateCredentialReportInput) (*request.Request, *iam.GenerateCredentialReportOutput)
 
 	GenerateCredentialReport(*iam.GenerateCredentialReportInput) (*iam.GenerateCredentialReportOutput, error)
 
-	GetAccessKeyLastUsedRequest(*iam.GetAccessKeyLastUsedInput) (*service.Request, *iam.GetAccessKeyLastUsedOutput)
+	GetAccessKeyLastUsedRequest(*iam.GetAccessKeyLastUsedInput) (*request.Request, *iam.GetAccessKeyLastUsedOutput)
 
 	GetAccessKeyLastUsed(*iam.GetAccessKeyLastUsedInput) (*iam.GetAccessKeyLastUsedOutput, error)
 
-	GetAccountAuthorizationDetailsRequest(*iam.GetAccountAuthorizationDetailsInput) (*service.Request, *iam.GetAccountAuthorizationDetailsOutput)
+	GetAccountAuthorizationDetailsRequest(*iam.GetAccountAuthorizationDetailsInput) (*request.Request, *iam.GetAccountAuthorizationDetailsOutput)
 
 	GetAccountAuthorizationDetails(*iam.GetAccountAuthorizationDetailsInput) (*iam.GetAccountAuthorizationDetailsOutput, error)
 
 	GetAccountAuthorizationDetailsPages(*iam.GetAccountAuthorizationDetailsInput, func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool) error
 
-	GetAccountPasswordPolicyRequest(*iam.GetAccountPasswordPolicyInput) (*service.Request, *iam.GetAccountPasswordPolicyOutput)
+	GetAccountPasswordPolicyRequest(*iam.GetAccountPasswordPolicyInput) (*request.Request, *iam.GetAccountPasswordPolicyOutput)
 
 	GetAccountPasswordPolicy(*iam.GetAccountPasswordPolicyInput) (*iam.GetAccountPasswordPolicyOutput, error)
 
-	GetAccountSummaryRequest(*iam.GetAccountSummaryInput) (*service.Request, *iam.GetAccountSummaryOutput)
+	GetAccountSummaryRequest(*iam.GetAccountSummaryInput) (*request.Request, *iam.GetAccountSummaryOutput)
 
 	GetAccountSummary(*iam.GetAccountSummaryInput) (*iam.GetAccountSummaryOutput, error)
 
-	GetCredentialReportRequest(*iam.GetCredentialReportInput) (*service.Request, *iam.GetCredentialReportOutput)
+	GetContextKeysForCustomPolicyRequest(*iam.GetContextKeysForCustomPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse)
+
+	GetContextKeysForCustomPolicy(*iam.GetContextKeysForCustomPolicyInput) (*iam.GetContextKeysForPolicyResponse, error)
+
+	GetContextKeysForPrincipalPolicyRequest(*iam.GetContextKeysForPrincipalPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse)
+
+	GetContextKeysForPrincipalPolicy(*iam.GetContextKeysForPrincipalPolicyInput) (*iam.GetContextKeysForPolicyResponse, error)
+
+	GetCredentialReportRequest(*iam.GetCredentialReportInput) (*request.Request, *iam.GetCredentialReportOutput)
 
 	GetCredentialReport(*iam.GetCredentialReportInput) (*iam.GetCredentialReportOutput, error)
 
-	GetGroupRequest(*iam.GetGroupInput) (*service.Request, *iam.GetGroupOutput)
+	GetGroupRequest(*iam.GetGroupInput) (*request.Request, *iam.GetGroupOutput)
 
 	GetGroup(*iam.GetGroupInput) (*iam.GetGroupOutput, error)
 
 	GetGroupPages(*iam.GetGroupInput, func(*iam.GetGroupOutput, bool) bool) error
 
-	GetGroupPolicyRequest(*iam.GetGroupPolicyInput) (*service.Request, *iam.GetGroupPolicyOutput)
+	GetGroupPolicyRequest(*iam.GetGroupPolicyInput) (*request.Request, *iam.GetGroupPolicyOutput)
 
 	GetGroupPolicy(*iam.GetGroupPolicyInput) (*iam.GetGroupPolicyOutput, error)
 
-	GetInstanceProfileRequest(*iam.GetInstanceProfileInput) (*service.Request, *iam.GetInstanceProfileOutput)
+	GetInstanceProfileRequest(*iam.GetInstanceProfileInput) (*request.Request, *iam.GetInstanceProfileOutput)
 
 	GetInstanceProfile(*iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error)
 
-	GetLoginProfileRequest(*iam.GetLoginProfileInput) (*service.Request, *iam.GetLoginProfileOutput)
+	GetLoginProfileRequest(*iam.GetLoginProfileInput) (*request.Request, *iam.GetLoginProfileOutput)
 
 	GetLoginProfile(*iam.GetLoginProfileInput) (*iam.GetLoginProfileOutput, error)
 
-	GetOpenIDConnectProviderRequest(*iam.GetOpenIDConnectProviderInput) (*service.Request, *iam.GetOpenIDConnectProviderOutput)
+	GetOpenIDConnectProviderRequest(*iam.GetOpenIDConnectProviderInput) (*request.Request, *iam.GetOpenIDConnectProviderOutput)
 
 	GetOpenIDConnectProvider(*iam.GetOpenIDConnectProviderInput) (*iam.GetOpenIDConnectProviderOutput, error)
 
-	GetPolicyRequest(*iam.GetPolicyInput) (*service.Request, *iam.GetPolicyOutput)
+	GetPolicyRequest(*iam.GetPolicyInput) (*request.Request, *iam.GetPolicyOutput)
 
 	GetPolicy(*iam.GetPolicyInput) (*iam.GetPolicyOutput, error)
 
-	GetPolicyVersionRequest(*iam.GetPolicyVersionInput) (*service.Request, *iam.GetPolicyVersionOutput)
+	GetPolicyVersionRequest(*iam.GetPolicyVersionInput) (*request.Request, *iam.GetPolicyVersionOutput)
 
 	GetPolicyVersion(*iam.GetPolicyVersionInput) (*iam.GetPolicyVersionOutput, error)
 
-	GetRoleRequest(*iam.GetRoleInput) (*service.Request, *iam.GetRoleOutput)
+	GetRoleRequest(*iam.GetRoleInput) (*request.Request, *iam.GetRoleOutput)
 
 	GetRole(*iam.GetRoleInput) (*iam.GetRoleOutput, error)
 
-	GetRolePolicyRequest(*iam.GetRolePolicyInput) (*service.Request, *iam.GetRolePolicyOutput)
+	GetRolePolicyRequest(*iam.GetRolePolicyInput) (*request.Request, *iam.GetRolePolicyOutput)
 
 	GetRolePolicy(*iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error)
 
-	GetSAMLProviderRequest(*iam.GetSAMLProviderInput) (*service.Request, *iam.GetSAMLProviderOutput)
+	GetSAMLProviderRequest(*iam.GetSAMLProviderInput) (*request.Request, *iam.GetSAMLProviderOutput)
 
 	GetSAMLProvider(*iam.GetSAMLProviderInput) (*iam.GetSAMLProviderOutput, error)
 
-	GetSSHPublicKeyRequest(*iam.GetSSHPublicKeyInput) (*service.Request, *iam.GetSSHPublicKeyOutput)
+	GetSSHPublicKeyRequest(*iam.GetSSHPublicKeyInput) (*request.Request, *iam.GetSSHPublicKeyOutput)
 
 	GetSSHPublicKey(*iam.GetSSHPublicKeyInput) (*iam.GetSSHPublicKeyOutput, error)
 
-	GetServerCertificateRequest(*iam.GetServerCertificateInput) (*service.Request, *iam.GetServerCertificateOutput)
+	GetServerCertificateRequest(*iam.GetServerCertificateInput) (*request.Request, *iam.GetServerCertificateOutput)
 
 	GetServerCertificate(*iam.GetServerCertificateInput) (*iam.GetServerCertificateOutput, error)
 
-	GetUserRequest(*iam.GetUserInput) (*service.Request, *iam.GetUserOutput)
+	GetUserRequest(*iam.GetUserInput) (*request.Request, *iam.GetUserOutput)
 
 	GetUser(*iam.GetUserInput) (*iam.GetUserOutput, error)
 
-	GetUserPolicyRequest(*iam.GetUserPolicyInput) (*service.Request, *iam.GetUserPolicyOutput)
+	GetUserPolicyRequest(*iam.GetUserPolicyInput) (*request.Request, *iam.GetUserPolicyOutput)
 
 	GetUserPolicy(*iam.GetUserPolicyInput) (*iam.GetUserPolicyOutput, error)
 
-	ListAccessKeysRequest(*iam.ListAccessKeysInput) (*service.Request, *iam.ListAccessKeysOutput)
+	ListAccessKeysRequest(*iam.ListAccessKeysInput) (*request.Request, *iam.ListAccessKeysOutput)
 
 	ListAccessKeys(*iam.ListAccessKeysInput) (*iam.ListAccessKeysOutput, error)
 
 	ListAccessKeysPages(*iam.ListAccessKeysInput, func(*iam.ListAccessKeysOutput, bool) bool) error
 
-	ListAccountAliasesRequest(*iam.ListAccountAliasesInput) (*service.Request, *iam.ListAccountAliasesOutput)
+	ListAccountAliasesRequest(*iam.ListAccountAliasesInput) (*request.Request, *iam.ListAccountAliasesOutput)
 
 	ListAccountAliases(*iam.ListAccountAliasesInput) (*iam.ListAccountAliasesOutput, error)
 
 	ListAccountAliasesPages(*iam.ListAccountAliasesInput, func(*iam.ListAccountAliasesOutput, bool) bool) error
 
-	ListAttachedGroupPoliciesRequest(*iam.ListAttachedGroupPoliciesInput) (*service.Request, *iam.ListAttachedGroupPoliciesOutput)
+	ListAttachedGroupPoliciesRequest(*iam.ListAttachedGroupPoliciesInput) (*request.Request, *iam.ListAttachedGroupPoliciesOutput)
 
 	ListAttachedGroupPolicies(*iam.ListAttachedGroupPoliciesInput) (*iam.ListAttachedGroupPoliciesOutput, error)
 
 	ListAttachedGroupPoliciesPages(*iam.ListAttachedGroupPoliciesInput, func(*iam.ListAttachedGroupPoliciesOutput, bool) bool) error
 
-	ListAttachedRolePoliciesRequest(*iam.ListAttachedRolePoliciesInput) (*service.Request, *iam.ListAttachedRolePoliciesOutput)
+	ListAttachedRolePoliciesRequest(*iam.ListAttachedRolePoliciesInput) (*request.Request, *iam.ListAttachedRolePoliciesOutput)
 
 	ListAttachedRolePolicies(*iam.ListAttachedRolePoliciesInput) (*iam.ListAttachedRolePoliciesOutput, error)
 
 	ListAttachedRolePoliciesPages(*iam.ListAttachedRolePoliciesInput, func(*iam.ListAttachedRolePoliciesOutput, bool) bool) error
 
-	ListAttachedUserPoliciesRequest(*iam.ListAttachedUserPoliciesInput) (*service.Request, *iam.ListAttachedUserPoliciesOutput)
+	ListAttachedUserPoliciesRequest(*iam.ListAttachedUserPoliciesInput) (*request.Request, *iam.ListAttachedUserPoliciesOutput)
 
 	ListAttachedUserPolicies(*iam.ListAttachedUserPoliciesInput) (*iam.ListAttachedUserPoliciesOutput, error)
 
 	ListAttachedUserPoliciesPages(*iam.ListAttachedUserPoliciesInput, func(*iam.ListAttachedUserPoliciesOutput, bool) bool) error
 
-	ListEntitiesForPolicyRequest(*iam.ListEntitiesForPolicyInput) (*service.Request, *iam.ListEntitiesForPolicyOutput)
+	ListEntitiesForPolicyRequest(*iam.ListEntitiesForPolicyInput) (*request.Request, *iam.ListEntitiesForPolicyOutput)
 
 	ListEntitiesForPolicy(*iam.ListEntitiesForPolicyInput) (*iam.ListEntitiesForPolicyOutput, error)
 
 	ListEntitiesForPolicyPages(*iam.ListEntitiesForPolicyInput, func(*iam.ListEntitiesForPolicyOutput, bool) bool) error
 
-	ListGroupPoliciesRequest(*iam.ListGroupPoliciesInput) (*service.Request, *iam.ListGroupPoliciesOutput)
+	ListGroupPoliciesRequest(*iam.ListGroupPoliciesInput) (*request.Request, *iam.ListGroupPoliciesOutput)
 
 	ListGroupPolicies(*iam.ListGroupPoliciesInput) (*iam.ListGroupPoliciesOutput, error)
 
 	ListGroupPoliciesPages(*iam.ListGroupPoliciesInput, func(*iam.ListGroupPoliciesOutput, bool) bool) error
 
-	ListGroupsRequest(*iam.ListGroupsInput) (*service.Request, *iam.ListGroupsOutput)
+	ListGroupsRequest(*iam.ListGroupsInput) (*request.Request, *iam.ListGroupsOutput)
 
 	ListGroups(*iam.ListGroupsInput) (*iam.ListGroupsOutput, error)
 
 	ListGroupsPages(*iam.ListGroupsInput, func(*iam.ListGroupsOutput, bool) bool) error
 
-	ListGroupsForUserRequest(*iam.ListGroupsForUserInput) (*service.Request, *iam.ListGroupsForUserOutput)
+	ListGroupsForUserRequest(*iam.ListGroupsForUserInput) (*request.Request, *iam.ListGroupsForUserOutput)
 
 	ListGroupsForUser(*iam.ListGroupsForUserInput) (*iam.ListGroupsForUserOutput, error)
 
 	ListGroupsForUserPages(*iam.ListGroupsForUserInput, func(*iam.ListGroupsForUserOutput, bool) bool) error
 
-	ListInstanceProfilesRequest(*iam.ListInstanceProfilesInput) (*service.Request, *iam.ListInstanceProfilesOutput)
+	ListInstanceProfilesRequest(*iam.ListInstanceProfilesInput) (*request.Request, *iam.ListInstanceProfilesOutput)
 
 	ListInstanceProfiles(*iam.ListInstanceProfilesInput) (*iam.ListInstanceProfilesOutput, error)
 
 	ListInstanceProfilesPages(*iam.ListInstanceProfilesInput, func(*iam.ListInstanceProfilesOutput, bool) bool) error
 
-	ListInstanceProfilesForRoleRequest(*iam.ListInstanceProfilesForRoleInput) (*service.Request, *iam.ListInstanceProfilesForRoleOutput)
+	ListInstanceProfilesForRoleRequest(*iam.ListInstanceProfilesForRoleInput) (*request.Request, *iam.ListInstanceProfilesForRoleOutput)
 
 	ListInstanceProfilesForRole(*iam.ListInstanceProfilesForRoleInput) (*iam.ListInstanceProfilesForRoleOutput, error)
 
 	ListInstanceProfilesForRolePages(*iam.ListInstanceProfilesForRoleInput, func(*iam.ListInstanceProfilesForRoleOutput, bool) bool) error
 
-	ListMFADevicesRequest(*iam.ListMFADevicesInput) (*service.Request, *iam.ListMFADevicesOutput)
+	ListMFADevicesRequest(*iam.ListMFADevicesInput) (*request.Request, *iam.ListMFADevicesOutput)
 
 	ListMFADevices(*iam.ListMFADevicesInput) (*iam.ListMFADevicesOutput, error)
 
 	ListMFADevicesPages(*iam.ListMFADevicesInput, func(*iam.ListMFADevicesOutput, bool) bool) error
 
-	ListOpenIDConnectProvidersRequest(*iam.ListOpenIDConnectProvidersInput) (*service.Request, *iam.ListOpenIDConnectProvidersOutput)
+	ListOpenIDConnectProvidersRequest(*iam.ListOpenIDConnectProvidersInput) (*request.Request, *iam.ListOpenIDConnectProvidersOutput)
 
 	ListOpenIDConnectProviders(*iam.ListOpenIDConnectProvidersInput) (*iam.ListOpenIDConnectProvidersOutput, error)
 
-	ListPoliciesRequest(*iam.ListPoliciesInput) (*service.Request, *iam.ListPoliciesOutput)
+	ListPoliciesRequest(*iam.ListPoliciesInput) (*request.Request, *iam.ListPoliciesOutput)
 
 	ListPolicies(*iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error)
 
 	ListPoliciesPages(*iam.ListPoliciesInput, func(*iam.ListPoliciesOutput, bool) bool) error
 
-	ListPolicyVersionsRequest(*iam.ListPolicyVersionsInput) (*service.Request, *iam.ListPolicyVersionsOutput)
+	ListPolicyVersionsRequest(*iam.ListPolicyVersionsInput) (*request.Request, *iam.ListPolicyVersionsOutput)
 
 	ListPolicyVersions(*iam.ListPolicyVersionsInput) (*iam.ListPolicyVersionsOutput, error)
 
-	ListRolePoliciesRequest(*iam.ListRolePoliciesInput) (*service.Request, *iam.ListRolePoliciesOutput)
+	ListRolePoliciesRequest(*iam.ListRolePoliciesInput) (*request.Request, *iam.ListRolePoliciesOutput)
 
 	ListRolePolicies(*iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error)
 
 	ListRolePoliciesPages(*iam.ListRolePoliciesInput, func(*iam.ListRolePoliciesOutput, bool) bool) error
 
-	ListRolesRequest(*iam.ListRolesInput) (*service.Request, *iam.ListRolesOutput)
+	ListRolesRequest(*iam.ListRolesInput) (*request.Request, *iam.ListRolesOutput)
 
 	ListRoles(*iam.ListRolesInput) (*iam.ListRolesOutput, error)
 
 	ListRolesPages(*iam.ListRolesInput, func(*iam.ListRolesOutput, bool) bool) error
 
-	ListSAMLProvidersRequest(*iam.ListSAMLProvidersInput) (*service.Request, *iam.ListSAMLProvidersOutput)
+	ListSAMLProvidersRequest(*iam.ListSAMLProvidersInput) (*request.Request, *iam.ListSAMLProvidersOutput)
 
 	ListSAMLProviders(*iam.ListSAMLProvidersInput) (*iam.ListSAMLProvidersOutput, error)
 
-	ListSSHPublicKeysRequest(*iam.ListSSHPublicKeysInput) (*service.Request, *iam.ListSSHPublicKeysOutput)
+	ListSSHPublicKeysRequest(*iam.ListSSHPublicKeysInput) (*request.Request, *iam.ListSSHPublicKeysOutput)
 
 	ListSSHPublicKeys(*iam.ListSSHPublicKeysInput) (*iam.ListSSHPublicKeysOutput, error)
 
-	ListServerCertificatesRequest(*iam.ListServerCertificatesInput) (*service.Request, *iam.ListServerCertificatesOutput)
+	ListServerCertificatesRequest(*iam.ListServerCertificatesInput) (*request.Request, *iam.ListServerCertificatesOutput)
 
 	ListServerCertificates(*iam.ListServerCertificatesInput) (*iam.ListServerCertificatesOutput, error)
 
 	ListServerCertificatesPages(*iam.ListServerCertificatesInput, func(*iam.ListServerCertificatesOutput, bool) bool) error
 
-	ListSigningCertificatesRequest(*iam.ListSigningCertificatesInput) (*service.Request, *iam.ListSigningCertificatesOutput)
+	ListSigningCertificatesRequest(*iam.ListSigningCertificatesInput) (*request.Request, *iam.ListSigningCertificatesOutput)
 
 	ListSigningCertificates(*iam.ListSigningCertificatesInput) (*iam.ListSigningCertificatesOutput, error)
 
 	ListSigningCertificatesPages(*iam.ListSigningCertificatesInput, func(*iam.ListSigningCertificatesOutput, bool) bool) error
 
-	ListUserPoliciesRequest(*iam.ListUserPoliciesInput) (*service.Request, *iam.ListUserPoliciesOutput)
+	ListUserPoliciesRequest(*iam.ListUserPoliciesInput) (*request.Request, *iam.ListUserPoliciesOutput)
 
 	ListUserPolicies(*iam.ListUserPoliciesInput) (*iam.ListUserPoliciesOutput, error)
 
 	ListUserPoliciesPages(*iam.ListUserPoliciesInput, func(*iam.ListUserPoliciesOutput, bool) bool) error
 
-	ListUsersRequest(*iam.ListUsersInput) (*service.Request, *iam.ListUsersOutput)
+	ListUsersRequest(*iam.ListUsersInput) (*request.Request, *iam.ListUsersOutput)
 
 	ListUsers(*iam.ListUsersInput) (*iam.ListUsersOutput, error)
 
 	ListUsersPages(*iam.ListUsersInput, func(*iam.ListUsersOutput, bool) bool) error
 
-	ListVirtualMFADevicesRequest(*iam.ListVirtualMFADevicesInput) (*service.Request, *iam.ListVirtualMFADevicesOutput)
+	ListVirtualMFADevicesRequest(*iam.ListVirtualMFADevicesInput) (*request.Request, *iam.ListVirtualMFADevicesOutput)
 
 	ListVirtualMFADevices(*iam.ListVirtualMFADevicesInput) (*iam.ListVirtualMFADevicesOutput, error)
 
 	ListVirtualMFADevicesPages(*iam.ListVirtualMFADevicesInput, func(*iam.ListVirtualMFADevicesOutput, bool) bool) error
 
-	PutGroupPolicyRequest(*iam.PutGroupPolicyInput) (*service.Request, *iam.PutGroupPolicyOutput)
+	PutGroupPolicyRequest(*iam.PutGroupPolicyInput) (*request.Request, *iam.PutGroupPolicyOutput)
 
 	PutGroupPolicy(*iam.PutGroupPolicyInput) (*iam.PutGroupPolicyOutput, error)
 
-	PutRolePolicyRequest(*iam.PutRolePolicyInput) (*service.Request, *iam.PutRolePolicyOutput)
+	PutRolePolicyRequest(*iam.PutRolePolicyInput) (*request.Request, *iam.PutRolePolicyOutput)
 
 	PutRolePolicy(*iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error)
 
-	PutUserPolicyRequest(*iam.PutUserPolicyInput) (*service.Request, *iam.PutUserPolicyOutput)
+	PutUserPolicyRequest(*iam.PutUserPolicyInput) (*request.Request, *iam.PutUserPolicyOutput)
 
 	PutUserPolicy(*iam.PutUserPolicyInput) (*iam.PutUserPolicyOutput, error)
 
-	RemoveClientIDFromOpenIDConnectProviderRequest(*iam.RemoveClientIDFromOpenIDConnectProviderInput) (*service.Request, *iam.RemoveClientIDFromOpenIDConnectProviderOutput)
+	RemoveClientIDFromOpenIDConnectProviderRequest(*iam.RemoveClientIDFromOpenIDConnectProviderInput) (*request.Request, *iam.RemoveClientIDFromOpenIDConnectProviderOutput)
 
 	RemoveClientIDFromOpenIDConnectProvider(*iam.RemoveClientIDFromOpenIDConnectProviderInput) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error)
 
-	RemoveRoleFromInstanceProfileRequest(*iam.RemoveRoleFromInstanceProfileInput) (*service.Request, *iam.RemoveRoleFromInstanceProfileOutput)
+	RemoveRoleFromInstanceProfileRequest(*iam.RemoveRoleFromInstanceProfileInput) (*request.Request, *iam.RemoveRoleFromInstanceProfileOutput)
 
 	RemoveRoleFromInstanceProfile(*iam.RemoveRoleFromInstanceProfileInput) (*iam.RemoveRoleFromInstanceProfileOutput, error)
 
-	RemoveUserFromGroupRequest(*iam.RemoveUserFromGroupInput) (*service.Request, *iam.RemoveUserFromGroupOutput)
+	RemoveUserFromGroupRequest(*iam.RemoveUserFromGroupInput) (*request.Request, *iam.RemoveUserFromGroupOutput)
 
 	RemoveUserFromGroup(*iam.RemoveUserFromGroupInput) (*iam.RemoveUserFromGroupOutput, error)
 
-	ResyncMFADeviceRequest(*iam.ResyncMFADeviceInput) (*service.Request, *iam.ResyncMFADeviceOutput)
+	ResyncMFADeviceRequest(*iam.ResyncMFADeviceInput) (*request.Request, *iam.ResyncMFADeviceOutput)
 
 	ResyncMFADevice(*iam.ResyncMFADeviceInput) (*iam.ResyncMFADeviceOutput, error)
 
-	SetDefaultPolicyVersionRequest(*iam.SetDefaultPolicyVersionInput) (*service.Request, *iam.SetDefaultPolicyVersionOutput)
+	SetDefaultPolicyVersionRequest(*iam.SetDefaultPolicyVersionInput) (*request.Request, *iam.SetDefaultPolicyVersionOutput)
 
 	SetDefaultPolicyVersion(*iam.SetDefaultPolicyVersionInput) (*iam.SetDefaultPolicyVersionOutput, error)
 
-	UpdateAccessKeyRequest(*iam.UpdateAccessKeyInput) (*service.Request, *iam.UpdateAccessKeyOutput)
+	SimulateCustomPolicyRequest(*iam.SimulateCustomPolicyInput) (*request.Request, *iam.SimulatePolicyResponse)
+
+	SimulateCustomPolicy(*iam.SimulateCustomPolicyInput) (*iam.SimulatePolicyResponse, error)
+
+	SimulatePrincipalPolicyRequest(*iam.SimulatePrincipalPolicyInput) (*request.Request, *iam.SimulatePolicyResponse)
+
+	SimulatePrincipalPolicy(*iam.SimulatePrincipalPolicyInput) (*iam.SimulatePolicyResponse, error)
+
+	UpdateAccessKeyRequest(*iam.UpdateAccessKeyInput) (*request.Request, *iam.UpdateAccessKeyOutput)
 
 	UpdateAccessKey(*iam.UpdateAccessKeyInput) (*iam.UpdateAccessKeyOutput, error)
 
-	UpdateAccountPasswordPolicyRequest(*iam.UpdateAccountPasswordPolicyInput) (*service.Request, *iam.UpdateAccountPasswordPolicyOutput)
+	UpdateAccountPasswordPolicyRequest(*iam.UpdateAccountPasswordPolicyInput) (*request.Request, *iam.UpdateAccountPasswordPolicyOutput)
 
 	UpdateAccountPasswordPolicy(*iam.UpdateAccountPasswordPolicyInput) (*iam.UpdateAccountPasswordPolicyOutput, error)
 
-	UpdateAssumeRolePolicyRequest(*iam.UpdateAssumeRolePolicyInput) (*service.Request, *iam.UpdateAssumeRolePolicyOutput)
+	UpdateAssumeRolePolicyRequest(*iam.UpdateAssumeRolePolicyInput) (*request.Request, *iam.UpdateAssumeRolePolicyOutput)
 
 	UpdateAssumeRolePolicy(*iam.UpdateAssumeRolePolicyInput) (*iam.UpdateAssumeRolePolicyOutput, error)
 
-	UpdateGroupRequest(*iam.UpdateGroupInput) (*service.Request, *iam.UpdateGroupOutput)
+	UpdateGroupRequest(*iam.UpdateGroupInput) (*request.Request, *iam.UpdateGroupOutput)
 
 	UpdateGroup(*iam.UpdateGroupInput) (*iam.UpdateGroupOutput, error)
 
-	UpdateLoginProfileRequest(*iam.UpdateLoginProfileInput) (*service.Request, *iam.UpdateLoginProfileOutput)
+	UpdateLoginProfileRequest(*iam.UpdateLoginProfileInput) (*request.Request, *iam.UpdateLoginProfileOutput)
 
 	UpdateLoginProfile(*iam.UpdateLoginProfileInput) (*iam.UpdateLoginProfileOutput, error)
 
-	UpdateOpenIDConnectProviderThumbprintRequest(*iam.UpdateOpenIDConnectProviderThumbprintInput) (*service.Request, *iam.UpdateOpenIDConnectProviderThumbprintOutput)
+	UpdateOpenIDConnectProviderThumbprintRequest(*iam.UpdateOpenIDConnectProviderThumbprintInput) (*request.Request, *iam.UpdateOpenIDConnectProviderThumbprintOutput)
 
 	UpdateOpenIDConnectProviderThumbprint(*iam.UpdateOpenIDConnectProviderThumbprintInput) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error)
 
-	UpdateSAMLProviderRequest(*iam.UpdateSAMLProviderInput) (*service.Request, *iam.UpdateSAMLProviderOutput)
+	UpdateSAMLProviderRequest(*iam.UpdateSAMLProviderInput) (*request.Request, *iam.UpdateSAMLProviderOutput)
 
 	UpdateSAMLProvider(*iam.UpdateSAMLProviderInput) (*iam.UpdateSAMLProviderOutput, error)
 
-	UpdateSSHPublicKeyRequest(*iam.UpdateSSHPublicKeyInput) (*service.Request, *iam.UpdateSSHPublicKeyOutput)
+	UpdateSSHPublicKeyRequest(*iam.UpdateSSHPublicKeyInput) (*request.Request, *iam.UpdateSSHPublicKeyOutput)
 
 	UpdateSSHPublicKey(*iam.UpdateSSHPublicKeyInput) (*iam.UpdateSSHPublicKeyOutput, error)
 
-	UpdateServerCertificateRequest(*iam.UpdateServerCertificateInput) (*service.Request, *iam.UpdateServerCertificateOutput)
+	UpdateServerCertificateRequest(*iam.UpdateServerCertificateInput) (*request.Request, *iam.UpdateServerCertificateOutput)
 
 	UpdateServerCertificate(*iam.UpdateServerCertificateInput) (*iam.UpdateServerCertificateOutput, error)
 
-	UpdateSigningCertificateRequest(*iam.UpdateSigningCertificateInput) (*service.Request, *iam.UpdateSigningCertificateOutput)
+	UpdateSigningCertificateRequest(*iam.UpdateSigningCertificateInput) (*request.Request, *iam.UpdateSigningCertificateOutput)
 
 	UpdateSigningCertificate(*iam.UpdateSigningCertificateInput) (*iam.UpdateSigningCertificateOutput, error)
 
-	UpdateUserRequest(*iam.UpdateUserInput) (*service.Request, *iam.UpdateUserOutput)
+	UpdateUserRequest(*iam.UpdateUserInput) (*request.Request, *iam.UpdateUserOutput)
 
 	UpdateUser(*iam.UpdateUserInput) (*iam.UpdateUserOutput, error)
 
-	UploadSSHPublicKeyRequest(*iam.UploadSSHPublicKeyInput) (*service.Request, *iam.UploadSSHPublicKeyOutput)
+	UploadSSHPublicKeyRequest(*iam.UploadSSHPublicKeyInput) (*request.Request, *iam.UploadSSHPublicKeyOutput)
 
 	UploadSSHPublicKey(*iam.UploadSSHPublicKeyInput) (*iam.UploadSSHPublicKeyOutput, error)
 
-	UploadServerCertificateRequest(*iam.UploadServerCertificateInput) (*service.Request, *iam.UploadServerCertificateOutput)
+	UploadServerCertificateRequest(*iam.UploadServerCertificateInput) (*request.Request, *iam.UploadServerCertificateOutput)
 
 	UploadServerCertificate(*iam.UploadServerCertificateInput) (*iam.UploadServerCertificateOutput, error)
 
-	UploadSigningCertificateRequest(*iam.UploadSigningCertificateInput) (*service.Request, *iam.UploadSigningCertificateOutput)
+	UploadSigningCertificateRequest(*iam.UploadSigningCertificateInput) (*request.Request, *iam.UploadSigningCertificateOutput)
 
 	UploadSigningCertificate(*iam.UploadSigningCertificateInput) (*iam.UploadSigningCertificateOutput, error)
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/iam/iamiface/interface_test.go

@@ -1,15 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package iamiface_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/service/iam"
-	"github.com/aws/aws-sdk-go/service/iam/iamiface"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestInterface(t *testing.T) {
-	assert.Implements(t, (*iamiface.IAMAPI)(nil), iam.New(nil))
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/iam/service.go

@@ -5,7 +5,9 @@ package iam
 import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/defaults"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 	"github.com/aws/aws-sdk-go/internal/protocol/query"
 	"github.com/aws/aws-sdk-go/internal/signer/v4"
 )
@@ -55,9 +57,7 @@ import (
 // This topic provides general information about the types of credentials used
 // for accessing AWS.   IAM Best Practices (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html).
 // This topic presents a list of suggestions for using the IAM service to help
-// secure your AWS resources.   AWS Security Token Service (http://docs.aws.amazon.com/STS/latest/UsingSTS/).
+// secure your AWS resources.   Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html).
-// This guide describes how to create and use temporary security credentials.
-//   Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html).
 // This set of topics walk you through the process of signing a request using
 // an access key ID and secret access key.
 type IAM struct {
@@ -68,14 +68,16 @@ type IAM struct {
 var initService func(*service.Service)
 
 // Used for custom request initialization logic
-var initRequest func(*service.Request)
+var initRequest func(*request.Request)
 
 // New returns a new IAM client.
 func New(config *aws.Config) *IAM {
 	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
+		ServiceInfo: serviceinfo.ServiceInfo{
-		ServiceName: "iam",
+			Config:      defaults.DefaultConfig.Merge(config),
-		APIVersion:  "2010-05-08",
+			ServiceName: "iam",
+			APIVersion:  "2010-05-08",
+		},
 	}
 	service.Initialize()
 
@@ -96,8 +98,8 @@ func New(config *aws.Config) *IAM {
 
 // newRequest creates a new request for a IAM operation and runs any
 // custom request initialization.
-func (c *IAM) newRequest(op *service.Operation, params, data interface{}) *service.Request {
+func (c *IAM) newRequest(op *request.Operation, params, data interface{}) *request.Request {
-	req := service.NewRequest(c.Service, op, params, data)
+	req := c.NewRequest(op, params, data)
 
 	// Run custom request initialization if present
 	if initRequest != nil {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/bucket_location.go

@@ -7,12 +7,12 @@ import (
 	"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/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 var reBucketLocation = regexp.MustCompile(`>([^<>]+)<\/Location`)
 
-func buildGetBucketLocation(r *service.Request) {
+func buildGetBucketLocation(r *request.Request) {
 	if r.DataFilled() {
 		out := r.Data.(*GetBucketLocationOutput)
 		b, err := ioutil.ReadAll(r.HTTPResponse.Body)
@@ -29,14 +29,14 @@ func buildGetBucketLocation(r *service.Request) {
 	}
 }
 
-func populateLocationConstraint(r *service.Request) {
+func populateLocationConstraint(r *request.Request) {
-	if r.ParamsFilled() && aws.StringValue(r.Config.Region) != "us-east-1" {
+	if r.ParamsFilled() && aws.StringValue(r.Service.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,
+				LocationConstraint: r.Service.Config.Region,
 			}
 		}
 	}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/bucket_location_test.go

@@ -1,76 +0,0 @@
-package s3_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-var s3LocationTests = []struct {
-	body string
-	loc  string
-}{
-	{`<?xml version="1.0" encoding="UTF-8"?><LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"/>`, ``},
-	{`<?xml version="1.0" encoding="UTF-8"?><LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/">EU</LocationConstraint>`, `EU`},
-}
-
-func TestGetBucketLocation(t *testing.T) {
-	for _, test := range s3LocationTests {
-		s := s3.New(nil)
-		s.Handlers.Send.Clear()
-		s.Handlers.Send.PushBack(func(r *service.Request) {
-			reader := ioutil.NopCloser(bytes.NewReader([]byte(test.body)))
-			r.HTTPResponse = &http.Response{StatusCode: 200, Body: reader}
-		})
-
-		resp, err := s.GetBucketLocation(&s3.GetBucketLocationInput{Bucket: aws.String("bucket")})
-		assert.NoError(t, err)
-		if test.loc == "" {
-			assert.Nil(t, resp.LocationConstraint)
-		} else {
-			assert.Equal(t, test.loc, *resp.LocationConstraint)
-		}
-	}
-}
-
-func TestPopulateLocationConstraint(t *testing.T) {
-	s := s3.New(nil)
-	in := &s3.CreateBucketInput{
-		Bucket: aws.String("bucket"),
-	}
-	req, _ := s.CreateBucketRequest(in)
-	err := req.Build()
-	assert.NoError(t, err)
-	assert.Equal(t, "mock-region", awsutil.ValuesAtPath(req.Params, "CreateBucketConfiguration.LocationConstraint")[0])
-	assert.Nil(t, in.CreateBucketConfiguration) // don't modify original params
-}
-
-func TestNoPopulateLocationConstraintIfProvided(t *testing.T) {
-	s := s3.New(nil)
-	req, _ := s.CreateBucketRequest(&s3.CreateBucketInput{
-		Bucket: aws.String("bucket"),
-		CreateBucketConfiguration: &s3.CreateBucketConfiguration{},
-	})
-	err := req.Build()
-	assert.NoError(t, err)
-	assert.Equal(t, 0, len(awsutil.ValuesAtPath(req.Params, "CreateBucketConfiguration.LocationConstraint")))
-}
-
-func TestNoPopulateLocationConstraintIfClassic(t *testing.T) {
-	s := s3.New(&aws.Config{Region: aws.String("us-east-1")})
-	req, _ := s.CreateBucketRequest(&s3.CreateBucketInput{
-		Bucket: aws.String("bucket"),
-	})
-	err := req.Build()
-	assert.NoError(t, err)
-	assert.Equal(t, 0, len(awsutil.ValuesAtPath(req.Params, "CreateBucketConfiguration.LocationConstraint")))
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/content_md5.go

@@ -6,12 +6,12 @@ import (
 	"io"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 // contentMD5 computes and sets the HTTP Content-MD5 header for requests that
 // require it.
-func contentMD5(r *service.Request) {
+func contentMD5(r *request.Request) {
 	h := md5.New()
 
 	// hash the body.  seek back to the first position after reading to reset

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/customizations.go

@@ -1,6 +1,9 @@
 package s3
 
-import "github.com/aws/aws-sdk-go/aws/service"
+import (
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/aws/service"
+)
 
 func init() {
 	initService = func(s *service.Service) {
@@ -16,7 +19,7 @@ func init() {
 		s.Handlers.UnmarshalError.PushBack(unmarshalError)
 	}
 
-	initRequest = func(r *service.Request) {
+	initRequest = func(r *request.Request) {
 		switch r.Operation.Name {
 		case opPutBucketCors, opPutBucketLifecycle, opPutBucketPolicy, opPutBucketTagging, opDeleteObjects:
 			// These S3 operations require Content-MD5 to be set
@@ -27,6 +30,8 @@ func init() {
 		case opCreateBucket:
 			// Auto-populate LocationConstraint with current region
 			r.Handlers.Validate.PushFront(populateLocationConstraint)
+		case opCopyObject, opUploadPartCopy, opCompleteMultipartUpload:
+			r.Handlers.Unmarshal.PushFront(copyMultipartStatusOKUnmarhsalError)
 		}
 	}
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/customizations_test.go

@@ -1,91 +0,0 @@
-package s3_test
-
-import (
-	"crypto/md5"
-	"encoding/base64"
-	"io/ioutil"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func assertMD5(t *testing.T, req *service.Request) {
-	err := req.Build()
-	assert.NoError(t, err)
-
-	b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
-	out := md5.Sum(b)
-	assert.NotEmpty(t, b)
-	assert.Equal(t, base64.StdEncoding.EncodeToString(out[:]), req.HTTPRequest.Header.Get("Content-MD5"))
-}
-
-func TestMD5InPutBucketCors(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutBucketCorsRequest(&s3.PutBucketCorsInput{
-		Bucket: aws.String("bucketname"),
-		CORSConfiguration: &s3.CORSConfiguration{
-			CORSRules: []*s3.CORSRule{
-				{AllowedMethods: []*string{aws.String("GET")}},
-			},
-		},
-	})
-	assertMD5(t, req)
-}
-
-func TestMD5InPutBucketLifecycle(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutBucketLifecycleRequest(&s3.PutBucketLifecycleInput{
-		Bucket: aws.String("bucketname"),
-		LifecycleConfiguration: &s3.LifecycleConfiguration{
-			Rules: []*s3.LifecycleRule{
-				{
-					ID:     aws.String("ID"),
-					Prefix: aws.String("Prefix"),
-					Status: aws.String("Enabled"),
-				},
-			},
-		},
-	})
-	assertMD5(t, req)
-}
-
-func TestMD5InPutBucketPolicy(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutBucketPolicyRequest(&s3.PutBucketPolicyInput{
-		Bucket: aws.String("bucketname"),
-		Policy: aws.String("{}"),
-	})
-	assertMD5(t, req)
-}
-
-func TestMD5InPutBucketTagging(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutBucketTaggingRequest(&s3.PutBucketTaggingInput{
-		Bucket: aws.String("bucketname"),
-		Tagging: &s3.Tagging{
-			TagSet: []*s3.Tag{
-				{Key: aws.String("KEY"), Value: aws.String("VALUE")},
-			},
-		},
-	})
-	assertMD5(t, req)
-}
-
-func TestMD5InDeleteObjects(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.DeleteObjectsRequest(&s3.DeleteObjectsInput{
-		Bucket: aws.String("bucketname"),
-		Delete: &s3.Delete{
-			Objects: []*s3.ObjectIdentifier{
-				{Key: aws.String("key")},
-			},
-		},
-	})
-	assertMD5(t, req)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/host_style_bucket.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 var reDomain = regexp.MustCompile(`^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$`)
@@ -23,8 +23,8 @@ func dnsCompatibleBucketName(bucket string) bool {
 // hostStyleBucketName 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 hostStyleBucketName(r *service.Request, bucket string) bool {
+func hostStyleBucketName(r *request.Request, bucket string) bool {
-	if aws.BoolValue(r.Config.S3ForcePathStyle) {
+	if aws.BoolValue(r.Service.Config.S3ForcePathStyle) {
 		return false
 	}
 
@@ -34,11 +34,17 @@ func hostStyleBucketName(r *service.Request, bucket string) bool {
 		return false
 	}
 
+	// GetBucketLocation should be able to be called from any region within
+	// a partition, and return the associated region of the bucket.
+	if r.Operation.Name == opGetBucketLocation {
+		return false
+	}
+
 	// Use host-style if the bucket is DNS compatible
 	return dnsCompatibleBucketName(bucket)
 }
 
-func updateHostWithBucket(r *service.Request) {
+func updateHostWithBucket(r *request.Request) {
 	b := awsutil.ValuesAtPath(r.Params, "Bucket")
 	if len(b) == 0 {
 		return

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/host_style_bucket_test.go

@@ -1,61 +0,0 @@
-package s3_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-type s3BucketTest struct {
-	bucket string
-	url    string
-}
-
-var (
-	_ = unit.Imported
-
-	sslTests = []s3BucketTest{
-		{"abc", "https://abc.s3.mock-region.amazonaws.com/"},
-		{"a$b$c", "https://s3.mock-region.amazonaws.com/a%24b%24c"},
-		{"a.b.c", "https://s3.mock-region.amazonaws.com/a.b.c"},
-		{"a..bc", "https://s3.mock-region.amazonaws.com/a..bc"},
-	}
-
-	nosslTests = []s3BucketTest{
-		{"a.b.c", "http://a.b.c.s3.mock-region.amazonaws.com/"},
-		{"a..bc", "http://s3.mock-region.amazonaws.com/a..bc"},
-	}
-
-	forcepathTests = []s3BucketTest{
-		{"abc", "https://s3.mock-region.amazonaws.com/abc"},
-		{"a$b$c", "https://s3.mock-region.amazonaws.com/a%24b%24c"},
-		{"a.b.c", "https://s3.mock-region.amazonaws.com/a.b.c"},
-		{"a..bc", "https://s3.mock-region.amazonaws.com/a..bc"},
-	}
-)
-
-func runTests(t *testing.T, svc *s3.S3, tests []s3BucketTest) {
-	for _, test := range tests {
-		req, _ := svc.ListObjectsRequest(&s3.ListObjectsInput{Bucket: &test.bucket})
-		req.Build()
-		assert.Equal(t, test.url, req.HTTPRequest.URL.String())
-	}
-}
-
-func TestHostStyleBucketBuild(t *testing.T) {
-	s := s3.New(nil)
-	runTests(t, s, sslTests)
-}
-
-func TestHostStyleBucketBuildNoSSL(t *testing.T) {
-	s := s3.New(&aws.Config{DisableSSL: aws.Bool(true)})
-	runTests(t, s, nosslTests)
-}
-
-func TestPathStyleBucketBuild(t *testing.T) {
-	s := s3.New(&aws.Config{S3ForcePathStyle: aws.Bool(true)})
-	runTests(t, s, forcepathTests)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3iface/interface.go

@@ -4,233 +4,241 @@
 package s3iface
 
 import (
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/s3"
 )
 
 // S3API is the interface type for s3.S3.
 type S3API interface {
-	AbortMultipartUploadRequest(*s3.AbortMultipartUploadInput) (*service.Request, *s3.AbortMultipartUploadOutput)
+	AbortMultipartUploadRequest(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)
 
 	AbortMultipartUpload(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)
 
-	CompleteMultipartUploadRequest(*s3.CompleteMultipartUploadInput) (*service.Request, *s3.CompleteMultipartUploadOutput)
+	CompleteMultipartUploadRequest(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)
 
 	CompleteMultipartUpload(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)
 
-	CopyObjectRequest(*s3.CopyObjectInput) (*service.Request, *s3.CopyObjectOutput)
+	CopyObjectRequest(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)
 
 	CopyObject(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)
 
-	CreateBucketRequest(*s3.CreateBucketInput) (*service.Request, *s3.CreateBucketOutput)
+	CreateBucketRequest(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)
 
 	CreateBucket(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)
 
-	CreateMultipartUploadRequest(*s3.CreateMultipartUploadInput) (*service.Request, *s3.CreateMultipartUploadOutput)
+	CreateMultipartUploadRequest(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)
 
 	CreateMultipartUpload(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)
 
-	DeleteBucketRequest(*s3.DeleteBucketInput) (*service.Request, *s3.DeleteBucketOutput)
+	DeleteBucketRequest(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)
 
 	DeleteBucket(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)
 
-	DeleteBucketCorsRequest(*s3.DeleteBucketCorsInput) (*service.Request, *s3.DeleteBucketCorsOutput)
+	DeleteBucketCorsRequest(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)
 
 	DeleteBucketCors(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)
 
-	DeleteBucketLifecycleRequest(*s3.DeleteBucketLifecycleInput) (*service.Request, *s3.DeleteBucketLifecycleOutput)
+	DeleteBucketLifecycleRequest(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)
 
 	DeleteBucketLifecycle(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)
 
-	DeleteBucketPolicyRequest(*s3.DeleteBucketPolicyInput) (*service.Request, *s3.DeleteBucketPolicyOutput)
+	DeleteBucketPolicyRequest(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)
 
 	DeleteBucketPolicy(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)
 
-	DeleteBucketReplicationRequest(*s3.DeleteBucketReplicationInput) (*service.Request, *s3.DeleteBucketReplicationOutput)
+	DeleteBucketReplicationRequest(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)
 
 	DeleteBucketReplication(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)
 
-	DeleteBucketTaggingRequest(*s3.DeleteBucketTaggingInput) (*service.Request, *s3.DeleteBucketTaggingOutput)
+	DeleteBucketTaggingRequest(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)
 
 	DeleteBucketTagging(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)
 
-	DeleteBucketWebsiteRequest(*s3.DeleteBucketWebsiteInput) (*service.Request, *s3.DeleteBucketWebsiteOutput)
+	DeleteBucketWebsiteRequest(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)
 
 	DeleteBucketWebsite(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)
 
-	DeleteObjectRequest(*s3.DeleteObjectInput) (*service.Request, *s3.DeleteObjectOutput)
+	DeleteObjectRequest(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)
 
 	DeleteObject(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)
 
-	DeleteObjectsRequest(*s3.DeleteObjectsInput) (*service.Request, *s3.DeleteObjectsOutput)
+	DeleteObjectsRequest(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)
 
 	DeleteObjects(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)
 
-	GetBucketAclRequest(*s3.GetBucketAclInput) (*service.Request, *s3.GetBucketAclOutput)
+	GetBucketAclRequest(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)
 
 	GetBucketAcl(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)
 
-	GetBucketCorsRequest(*s3.GetBucketCorsInput) (*service.Request, *s3.GetBucketCorsOutput)
+	GetBucketCorsRequest(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)
 
 	GetBucketCors(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)
 
-	GetBucketLifecycleRequest(*s3.GetBucketLifecycleInput) (*service.Request, *s3.GetBucketLifecycleOutput)
+	GetBucketLifecycleRequest(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)
 
 	GetBucketLifecycle(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)
 
-	GetBucketLocationRequest(*s3.GetBucketLocationInput) (*service.Request, *s3.GetBucketLocationOutput)
+	GetBucketLifecycleConfigurationRequest(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)
+
+	GetBucketLifecycleConfiguration(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)
+
+	GetBucketLocationRequest(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)
 
 	GetBucketLocation(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)
 
-	GetBucketLoggingRequest(*s3.GetBucketLoggingInput) (*service.Request, *s3.GetBucketLoggingOutput)
+	GetBucketLoggingRequest(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)
 
 	GetBucketLogging(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)
 
-	GetBucketNotificationRequest(*s3.GetBucketNotificationConfigurationRequest) (*service.Request, *s3.NotificationConfigurationDeprecated)
+	GetBucketNotificationRequest(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)
 
 	GetBucketNotification(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)
 
-	GetBucketNotificationConfigurationRequest(*s3.GetBucketNotificationConfigurationRequest) (*service.Request, *s3.NotificationConfiguration)
+	GetBucketNotificationConfigurationRequest(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)
 
 	GetBucketNotificationConfiguration(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)
 
-	GetBucketPolicyRequest(*s3.GetBucketPolicyInput) (*service.Request, *s3.GetBucketPolicyOutput)
+	GetBucketPolicyRequest(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)
 
 	GetBucketPolicy(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)
 
-	GetBucketReplicationRequest(*s3.GetBucketReplicationInput) (*service.Request, *s3.GetBucketReplicationOutput)
+	GetBucketReplicationRequest(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)
 
 	GetBucketReplication(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)
 
-	GetBucketRequestPaymentRequest(*s3.GetBucketRequestPaymentInput) (*service.Request, *s3.GetBucketRequestPaymentOutput)
+	GetBucketRequestPaymentRequest(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)
 
 	GetBucketRequestPayment(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)
 
-	GetBucketTaggingRequest(*s3.GetBucketTaggingInput) (*service.Request, *s3.GetBucketTaggingOutput)
+	GetBucketTaggingRequest(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)
 
 	GetBucketTagging(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)
 
-	GetBucketVersioningRequest(*s3.GetBucketVersioningInput) (*service.Request, *s3.GetBucketVersioningOutput)
+	GetBucketVersioningRequest(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)
 
 	GetBucketVersioning(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)
 
-	GetBucketWebsiteRequest(*s3.GetBucketWebsiteInput) (*service.Request, *s3.GetBucketWebsiteOutput)
+	GetBucketWebsiteRequest(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)
 
 	GetBucketWebsite(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)
 
-	GetObjectRequest(*s3.GetObjectInput) (*service.Request, *s3.GetObjectOutput)
+	GetObjectRequest(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)
 
 	GetObject(*s3.GetObjectInput) (*s3.GetObjectOutput, error)
 
-	GetObjectAclRequest(*s3.GetObjectAclInput) (*service.Request, *s3.GetObjectAclOutput)
+	GetObjectAclRequest(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)
 
 	GetObjectAcl(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)
 
-	GetObjectTorrentRequest(*s3.GetObjectTorrentInput) (*service.Request, *s3.GetObjectTorrentOutput)
+	GetObjectTorrentRequest(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)
 
 	GetObjectTorrent(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)
 
-	HeadBucketRequest(*s3.HeadBucketInput) (*service.Request, *s3.HeadBucketOutput)
+	HeadBucketRequest(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)
 
 	HeadBucket(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)
 
-	HeadObjectRequest(*s3.HeadObjectInput) (*service.Request, *s3.HeadObjectOutput)
+	HeadObjectRequest(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)
 
 	HeadObject(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)
 
-	ListBucketsRequest(*s3.ListBucketsInput) (*service.Request, *s3.ListBucketsOutput)
+	ListBucketsRequest(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)
 
 	ListBuckets(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)
 
-	ListMultipartUploadsRequest(*s3.ListMultipartUploadsInput) (*service.Request, *s3.ListMultipartUploadsOutput)
+	ListMultipartUploadsRequest(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)
 
 	ListMultipartUploads(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)
 
 	ListMultipartUploadsPages(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error
 
-	ListObjectVersionsRequest(*s3.ListObjectVersionsInput) (*service.Request, *s3.ListObjectVersionsOutput)
+	ListObjectVersionsRequest(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)
 
 	ListObjectVersions(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)
 
 	ListObjectVersionsPages(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error
 
-	ListObjectsRequest(*s3.ListObjectsInput) (*service.Request, *s3.ListObjectsOutput)
+	ListObjectsRequest(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)
 
 	ListObjects(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)
 
 	ListObjectsPages(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error
 
-	ListPartsRequest(*s3.ListPartsInput) (*service.Request, *s3.ListPartsOutput)
+	ListPartsRequest(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)
 
 	ListParts(*s3.ListPartsInput) (*s3.ListPartsOutput, error)
 
 	ListPartsPages(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error
 
-	PutBucketAclRequest(*s3.PutBucketAclInput) (*service.Request, *s3.PutBucketAclOutput)
+	PutBucketAclRequest(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)
 
 	PutBucketAcl(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)
 
-	PutBucketCorsRequest(*s3.PutBucketCorsInput) (*service.Request, *s3.PutBucketCorsOutput)
+	PutBucketCorsRequest(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)
 
 	PutBucketCors(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)
 
-	PutBucketLifecycleRequest(*s3.PutBucketLifecycleInput) (*service.Request, *s3.PutBucketLifecycleOutput)
+	PutBucketLifecycleRequest(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)
 
 	PutBucketLifecycle(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)
 
-	PutBucketLoggingRequest(*s3.PutBucketLoggingInput) (*service.Request, *s3.PutBucketLoggingOutput)
+	PutBucketLifecycleConfigurationRequest(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)
+
+	PutBucketLifecycleConfiguration(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)
+
+	PutBucketLoggingRequest(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)
 
 	PutBucketLogging(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)
 
-	PutBucketNotificationRequest(*s3.PutBucketNotificationInput) (*service.Request, *s3.PutBucketNotificationOutput)
+	PutBucketNotificationRequest(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)
 
 	PutBucketNotification(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)
 
-	PutBucketNotificationConfigurationRequest(*s3.PutBucketNotificationConfigurationInput) (*service.Request, *s3.PutBucketNotificationConfigurationOutput)
+	PutBucketNotificationConfigurationRequest(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)
 
 	PutBucketNotificationConfiguration(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)
 
-	PutBucketPolicyRequest(*s3.PutBucketPolicyInput) (*service.Request, *s3.PutBucketPolicyOutput)
+	PutBucketPolicyRequest(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)
 
 	PutBucketPolicy(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)
 
-	PutBucketReplicationRequest(*s3.PutBucketReplicationInput) (*service.Request, *s3.PutBucketReplicationOutput)
+	PutBucketReplicationRequest(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)
 
 	PutBucketReplication(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)
 
-	PutBucketRequestPaymentRequest(*s3.PutBucketRequestPaymentInput) (*service.Request, *s3.PutBucketRequestPaymentOutput)
+	PutBucketRequestPaymentRequest(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)
 
 	PutBucketRequestPayment(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)
 
-	PutBucketTaggingRequest(*s3.PutBucketTaggingInput) (*service.Request, *s3.PutBucketTaggingOutput)
+	PutBucketTaggingRequest(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)
 
 	PutBucketTagging(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)
 
-	PutBucketVersioningRequest(*s3.PutBucketVersioningInput) (*service.Request, *s3.PutBucketVersioningOutput)
+	PutBucketVersioningRequest(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)
 
 	PutBucketVersioning(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)
 
-	PutBucketWebsiteRequest(*s3.PutBucketWebsiteInput) (*service.Request, *s3.PutBucketWebsiteOutput)
+	PutBucketWebsiteRequest(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)
 
 	PutBucketWebsite(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)
 
-	PutObjectRequest(*s3.PutObjectInput) (*service.Request, *s3.PutObjectOutput)
+	PutObjectRequest(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)
 
 	PutObject(*s3.PutObjectInput) (*s3.PutObjectOutput, error)
 
-	PutObjectAclRequest(*s3.PutObjectAclInput) (*service.Request, *s3.PutObjectAclOutput)
+	PutObjectAclRequest(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)
 
 	PutObjectAcl(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)
 
-	RestoreObjectRequest(*s3.RestoreObjectInput) (*service.Request, *s3.RestoreObjectOutput)
+	RestoreObjectRequest(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)
 
 	RestoreObject(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)
 
-	UploadPartRequest(*s3.UploadPartInput) (*service.Request, *s3.UploadPartOutput)
+	UploadPartRequest(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)
 
 	UploadPart(*s3.UploadPartInput) (*s3.UploadPartOutput, error)
 
-	UploadPartCopyRequest(*s3.UploadPartCopyInput) (*service.Request, *s3.UploadPartCopyOutput)
+	UploadPartCopyRequest(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)
 
 	UploadPartCopy(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)
 }

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3iface/interface_test.go

@@ -1,15 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package s3iface_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3iface"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestInterface(t *testing.T) {
-	assert.Implements(t, (*s3iface.S3API)(nil), s3.New(nil))
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3manager/download.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws/awsutil"
 	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go/service/s3/s3iface"
 )
 
 // The default range of bytes to get at a time when using Download().
@@ -37,7 +38,7 @@ type DownloadOptions struct {
 
 	// An S3 client to use when performing downloads. Leave this as nil to use
 	// a default client.
-	S3 *s3.S3
+	S3 s3iface.S3API
 }
 
 // NewDownloader creates a new Downloader structure that downloads an object

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3manager/download_test.go

@@ -1,141 +0,0 @@
-package s3manager_test
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"regexp"
-	"strconv"
-	"sync"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func dlLoggingSvc(data []byte) (*s3.S3, *[]string, *[]string) {
-	var m sync.Mutex
-	names := []string{}
-	ranges := []string{}
-
-	svc := s3.New(nil)
-	svc.Handlers.Send.Clear()
-	svc.Handlers.Send.PushBack(func(r *service.Request) {
-		m.Lock()
-		defer m.Unlock()
-
-		names = append(names, r.Operation.Name)
-		ranges = append(ranges, *r.Params.(*s3.GetObjectInput).Range)
-
-		rerng := regexp.MustCompile(`bytes=(\d+)-(\d+)`)
-		rng := rerng.FindStringSubmatch(r.HTTPRequest.Header.Get("Range"))
-		start, _ := strconv.ParseInt(rng[1], 10, 64)
-		fin, _ := strconv.ParseInt(rng[2], 10, 64)
-		fin++
-
-		if fin > int64(len(data)) {
-			fin = int64(len(data))
-		}
-
-		r.HTTPResponse = &http.Response{
-			StatusCode: 200,
-			Body:       ioutil.NopCloser(bytes.NewReader(data[start:fin])),
-			Header:     http.Header{},
-		}
-		r.HTTPResponse.Header.Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d",
-			start, fin, len(data)))
-	})
-
-	return svc, &names, &ranges
-}
-
-func TestDownloadOrder(t *testing.T) {
-	s, names, ranges := dlLoggingSvc(buf12MB)
-
-	opts := &s3manager.DownloadOptions{S3: s, Concurrency: 1}
-	d := s3manager.NewDownloader(opts)
-	w := &aws.WriteAtBuffer{}
-	n, err := d.Download(w, &s3.GetObjectInput{
-		Bucket: aws.String("bucket"),
-		Key:    aws.String("key"),
-	})
-
-	assert.Nil(t, err)
-	assert.Equal(t, int64(len(buf12MB)), n)
-	assert.Equal(t, []string{"GetObject", "GetObject", "GetObject"}, *names)
-	assert.Equal(t, []string{"bytes=0-5242879", "bytes=5242880-10485759", "bytes=10485760-15728639"}, *ranges)
-
-	count := 0
-	for _, b := range w.Bytes() {
-		count += int(b)
-	}
-	assert.Equal(t, 0, count)
-}
-
-func TestDownloadZero(t *testing.T) {
-	s, names, ranges := dlLoggingSvc([]byte{})
-
-	opts := &s3manager.DownloadOptions{S3: s}
-	d := s3manager.NewDownloader(opts)
-	w := &aws.WriteAtBuffer{}
-	n, err := d.Download(w, &s3.GetObjectInput{
-		Bucket: aws.String("bucket"),
-		Key:    aws.String("key"),
-	})
-
-	assert.Nil(t, err)
-	assert.Equal(t, int64(0), n)
-	assert.Equal(t, []string{"GetObject"}, *names)
-	assert.Equal(t, []string{"bytes=0-5242879"}, *ranges)
-}
-
-func TestDownloadSetPartSize(t *testing.T) {
-	s, names, ranges := dlLoggingSvc([]byte{1, 2, 3})
-
-	opts := &s3manager.DownloadOptions{S3: s, PartSize: 1, Concurrency: 1}
-	d := s3manager.NewDownloader(opts)
-	w := &aws.WriteAtBuffer{}
-	n, err := d.Download(w, &s3.GetObjectInput{
-		Bucket: aws.String("bucket"),
-		Key:    aws.String("key"),
-	})
-
-	assert.Nil(t, err)
-	assert.Equal(t, int64(3), n)
-	assert.Equal(t, []string{"GetObject", "GetObject", "GetObject"}, *names)
-	assert.Equal(t, []string{"bytes=0-0", "bytes=1-1", "bytes=2-2"}, *ranges)
-	assert.Equal(t, []byte{1, 2, 3}, w.Bytes())
-}
-
-func TestDownloadError(t *testing.T) {
-	s, names, _ := dlLoggingSvc([]byte{1, 2, 3})
-	opts := &s3manager.DownloadOptions{S3: s, PartSize: 1, Concurrency: 1}
-
-	num := 0
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		num++
-		if num > 1 {
-			r.HTTPResponse.StatusCode = 400
-			r.HTTPResponse.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
-		}
-	})
-
-	d := s3manager.NewDownloader(opts)
-	w := &aws.WriteAtBuffer{}
-	n, err := d.Download(w, &s3.GetObjectInput{
-		Bucket: aws.String("bucket"),
-		Key:    aws.String("key"),
-	})
-
-	assert.NotNil(t, err)
-	assert.Equal(t, int64(1), n)
-	assert.Equal(t, []string{"GetObject", "GetObject"}, *names)
-	assert.Equal(t, []byte{1}, w.Bytes())
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3manager/upload.go

@@ -11,6 +11,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/awsutil"
 	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go/service/s3/s3iface"
 )
 
 // The maximum allowed number of parts in a multi-part upload on Amazon S3.
@@ -215,7 +216,7 @@ type UploadOptions struct {
 
 	// The client to use when uploading to S3. Leave this as nil to use the
 	// default S3 client.
-	S3 *s3.S3
+	S3 s3iface.S3API
 }
 
 // NewUploader creates a new Uploader object to upload data to S3. Pass in

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/s3manager/upload_test.go

@@ -1,463 +0,0 @@
-package s3manager_test
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"sort"
-	"sync"
-	"testing"
-	"strings"
-	"net/http/httptest"
-
-	"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/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/aws/aws-sdk-go/service/s3/s3manager"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-var buf12MB = make([]byte, 1024*1024*12)
-var buf2MB = make([]byte, 1024*1024*2)
-
-var emptyList = []string{}
-
-func val(i interface{}, s string) interface{} {
-	return awsutil.ValuesAtPath(i, s)[0]
-}
-
-func contains(src []string, s string) bool {
-	for _, v := range src {
-		if s == v {
-			return true
-		}
-	}
-	return false
-}
-
-func loggingSvc(ignoreOps []string) (*s3.S3, *[]string, *[]interface{}) {
-	var m sync.Mutex
-	partNum := 0
-	names := []string{}
-	params := []interface{}{}
-	svc := s3.New(nil)
-	svc.Handlers.Unmarshal.Clear()
-	svc.Handlers.UnmarshalMeta.Clear()
-	svc.Handlers.UnmarshalError.Clear()
-	svc.Handlers.Send.Clear()
-	svc.Handlers.Send.PushBack(func(r *service.Request) {
-		m.Lock()
-		defer m.Unlock()
-
-		if !contains(ignoreOps, r.Operation.Name) {
-			names = append(names, r.Operation.Name)
-			params = append(params, r.Params)
-		}
-
-		r.HTTPResponse = &http.Response{
-			StatusCode: 200,
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-		}
-
-		switch data := r.Data.(type) {
-		case *s3.CreateMultipartUploadOutput:
-			data.UploadId = aws.String("UPLOAD-ID")
-		case *s3.UploadPartOutput:
-			partNum++
-			data.ETag = aws.String(fmt.Sprintf("ETAG%d", partNum))
-		case *s3.CompleteMultipartUploadOutput:
-			data.Location = aws.String("https://location")
-		}
-	})
-
-	return svc, &names, &params
-}
-
-func buflen(i interface{}) int {
-	r := i.(io.Reader)
-	b, _ := ioutil.ReadAll(r)
-	return len(b)
-}
-
-func TestUploadOrderMulti(t *testing.T) {
-	s, ops, args := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket:               aws.String("Bucket"),
-		Key:                  aws.String("Key"),
-		Body:                 bytes.NewReader(buf12MB),
-		ServerSideEncryption: aws.String("AES256"),
-		ContentType:          aws.String("content/type"),
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "UploadPart", "CompleteMultipartUpload"}, *ops)
-	assert.Equal(t, "https://location", resp.Location)
-	assert.Equal(t, "UPLOAD-ID", resp.UploadID)
-
-	// Validate input values
-
-	// UploadPart
-	assert.Equal(t, "UPLOAD-ID", val((*args)[1], "UploadId"))
-	assert.Equal(t, "UPLOAD-ID", val((*args)[2], "UploadId"))
-	assert.Equal(t, "UPLOAD-ID", val((*args)[3], "UploadId"))
-
-	// CompleteMultipartUpload
-	assert.Equal(t, "UPLOAD-ID", val((*args)[4], "UploadId"))
-	assert.Equal(t, int64(1), val((*args)[4], "MultipartUpload.Parts[0].PartNumber"))
-	assert.Equal(t, int64(2), val((*args)[4], "MultipartUpload.Parts[1].PartNumber"))
-	assert.Equal(t, int64(3), val((*args)[4], "MultipartUpload.Parts[2].PartNumber"))
-	assert.Regexp(t, `^ETAG\d+$`, val((*args)[4], "MultipartUpload.Parts[0].ETag"))
-	assert.Regexp(t, `^ETAG\d+$`, val((*args)[4], "MultipartUpload.Parts[1].ETag"))
-	assert.Regexp(t, `^ETAG\d+$`, val((*args)[4], "MultipartUpload.Parts[2].ETag"))
-
-	// Custom headers
-	assert.Equal(t, "AES256", val((*args)[0], "ServerSideEncryption"))
-	assert.Equal(t, "content/type", val((*args)[0], "ContentType"))
-}
-
-func TestUploadOrderMultiDifferentPartSize(t *testing.T) {
-	s, ops, args := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{
-		S3:          s,
-		PartSize:    1024 * 1024 * 7,
-		Concurrency: 1,
-	})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf12MB),
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "CompleteMultipartUpload"}, *ops)
-
-	// Part lengths
-	assert.Equal(t, 1024*1024*7, buflen(val((*args)[1], "Body")))
-	assert.Equal(t, 1024*1024*5, buflen(val((*args)[2], "Body")))
-}
-
-func TestUploadIncreasePartSize(t *testing.T) {
-	s3manager.MaxUploadParts = 2
-	defer func() { s3manager.MaxUploadParts = 10000 }()
-
-	s, ops, args := loggingSvc(emptyList)
-	opts := &s3manager.UploadOptions{S3: s, Concurrency: 1}
-	mgr := s3manager.NewUploader(opts)
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf12MB),
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, int64(0), opts.PartSize) // don't modify orig options
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "CompleteMultipartUpload"}, *ops)
-
-	// Part lengths
-	assert.Equal(t, 1024*1024*6, buflen(val((*args)[1], "Body")))
-	assert.Equal(t, 1024*1024*6, buflen(val((*args)[2], "Body")))
-}
-
-func TestUploadFailIfPartSizeTooSmall(t *testing.T) {
-	opts := &s3manager.UploadOptions{PartSize: 5}
-	mgr := s3manager.NewUploader(opts)
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf12MB),
-	})
-
-	assert.Nil(t, resp)
-	assert.NotNil(t, err)
-
-	aerr := err.(awserr.Error)
-	assert.Equal(t, "ConfigError", aerr.Code())
-	assert.Contains(t, aerr.Message(), "part size must be at least")
-}
-
-func TestUploadOrderSingle(t *testing.T) {
-	s, ops, args := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket:               aws.String("Bucket"),
-		Key:                  aws.String("Key"),
-		Body:                 bytes.NewReader(buf2MB),
-		ServerSideEncryption: aws.String("AES256"),
-		ContentType:          aws.String("content/type"),
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"PutObject"}, *ops)
-	assert.NotEqual(t, "", resp.Location)
-	assert.Equal(t, "", resp.UploadID)
-	assert.Equal(t, "AES256", val((*args)[0], "ServerSideEncryption"))
-	assert.Equal(t, "content/type", val((*args)[0], "ContentType"))
-}
-
-func TestUploadOrderSingleFailure(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		r.HTTPResponse.StatusCode = 400
-	})
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf2MB),
-	})
-
-	assert.Error(t, err)
-	assert.Equal(t, []string{"PutObject"}, *ops)
-	assert.Nil(t, resp)
-}
-
-func TestUploadOrderZero(t *testing.T) {
-	s, ops, args := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(make([]byte, 0)),
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"PutObject"}, *ops)
-	assert.NotEqual(t, "", resp.Location)
-	assert.Equal(t, "", resp.UploadID)
-	assert.Equal(t, 0, buflen(val((*args)[0], "Body")))
-}
-
-func TestUploadOrderMultiFailure(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		switch t := r.Data.(type) {
-		case *s3.UploadPartOutput:
-			if *t.ETag == "ETAG2" {
-				r.HTTPResponse.StatusCode = 400
-			}
-		}
-	})
-
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s, Concurrency: 1})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf12MB),
-	})
-
-	assert.Error(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "AbortMultipartUpload"}, *ops)
-}
-
-func TestUploadOrderMultiFailureOnComplete(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		switch r.Data.(type) {
-		case *s3.CompleteMultipartUploadOutput:
-			r.HTTPResponse.StatusCode = 400
-		}
-	})
-
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s, Concurrency: 1})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(buf12MB),
-	})
-
-	assert.Error(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart",
-		"UploadPart", "CompleteMultipartUpload", "AbortMultipartUpload"}, *ops)
-}
-
-func TestUploadOrderMultiFailureOnCreate(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		switch r.Data.(type) {
-		case *s3.CreateMultipartUploadOutput:
-			r.HTTPResponse.StatusCode = 400
-		}
-	})
-
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(make([]byte, 1024*1024*12)),
-	})
-
-	assert.Error(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload"}, *ops)
-}
-
-func TestUploadOrderMultiFailureLeaveParts(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	s.Handlers.Send.PushBack(func(r *service.Request) {
-		switch data := r.Data.(type) {
-		case *s3.UploadPartOutput:
-			if *data.ETag == "ETAG2" {
-				r.HTTPResponse.StatusCode = 400
-			}
-		}
-	})
-
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{
-		S3:                s,
-		Concurrency:       1,
-		LeavePartsOnError: true,
-	})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   bytes.NewReader(make([]byte, 1024*1024*12)),
-	})
-
-	assert.Error(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart"}, *ops)
-}
-
-type failreader struct {
-	times     int
-	failCount int
-}
-
-func (f *failreader) Read(b []byte) (int, error) {
-	f.failCount++
-	if f.failCount >= f.times {
-		return 0, fmt.Errorf("random failure")
-	}
-	return len(b), nil
-}
-
-func TestUploadOrderReadFail1(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   &failreader{times: 1},
-	})
-
-	assert.Equal(t, "ReadRequestBody", err.(awserr.Error).Code())
-	assert.EqualError(t, err.(awserr.Error).OrigErr(), "random failure")
-	assert.Equal(t, []string{}, *ops)
-}
-
-func TestUploadOrderReadFail2(t *testing.T) {
-	s, ops, _ := loggingSvc([]string{"UploadPart"})
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s, Concurrency: 1})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   &failreader{times: 2},
-	})
-
-	assert.Equal(t, "ReadRequestBody", err.(awserr.Error).Code())
-	assert.EqualError(t, err.(awserr.Error).OrigErr(), "random failure")
-	assert.Equal(t, []string{"CreateMultipartUpload", "AbortMultipartUpload"}, *ops)
-}
-
-type sizedReader struct {
-	size int
-	cur  int
-}
-
-func (s *sizedReader) Read(p []byte) (n int, err error) {
-	if s.cur >= s.size {
-		return 0, io.EOF
-	}
-
-	n = len(p)
-	s.cur += len(p)
-	if s.cur > s.size {
-		n -= s.cur - s.size
-	}
-
-	return
-}
-
-func TestUploadOrderMultiBufferedReader(t *testing.T) {
-	s, ops, args := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	_, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   &sizedReader{size: 1024 * 1024 * 12},
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart", "UploadPart", "CompleteMultipartUpload"}, *ops)
-
-	// Part lengths
-	parts := []int{
-		buflen(val((*args)[1], "Body")),
-		buflen(val((*args)[2], "Body")),
-		buflen(val((*args)[3], "Body")),
-	}
-	sort.Ints(parts)
-	assert.Equal(t, []int{1024 * 1024 * 2, 1024 * 1024 * 5, 1024 * 1024 * 5}, parts)
-}
-
-func TestUploadOrderMultiBufferedReaderExceedTotalParts(t *testing.T) {
-	s3manager.MaxUploadParts = 2
-	defer func() { s3manager.MaxUploadParts = 10000 }()
-	s, ops, _ := loggingSvc([]string{"UploadPart"})
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s, Concurrency: 1})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   &sizedReader{size: 1024 * 1024 * 12},
-	})
-
-	assert.Error(t, err)
-	assert.Nil(t, resp)
-	assert.Equal(t, []string{"CreateMultipartUpload", "AbortMultipartUpload"}, *ops)
-
-	aerr := err.(awserr.Error)
-	assert.Equal(t, "TotalPartsExceeded", aerr.Code())
-	assert.Contains(t, aerr.Message(), "exceeded total allowed parts (2)")
-}
-
-func TestUploadOrderSingleBufferedReader(t *testing.T) {
-	s, ops, _ := loggingSvc(emptyList)
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   &sizedReader{size: 1024 * 1024 * 2},
-	})
-
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"PutObject"}, *ops)
-	assert.NotEqual(t, "", resp.Location)
-	assert.Equal(t, "", resp.UploadID)
-}
-
-func TestUploadZeroLenObject(t *testing.T) {
-	requestMade := false
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
-		requestMade = true
-		w.WriteHeader(http.StatusOK)
-	}))
-	svc := s3.New(&aws.Config{
-		Endpoint: aws.String(server.URL),
-	})
-	mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: svc})
-	resp, err := mgr.Upload(&s3manager.UploadInput{
-		Bucket: aws.String("Bucket"),
-		Key:    aws.String("Key"),
-		Body:   strings.NewReader(""),
-	})
-
-	assert.NoError(t, err)
-	assert.True(t, requestMade)
-	assert.NotEqual(t, "", resp.Location)
-	assert.Equal(t, "", resp.UploadID)
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/service.go

@@ -5,7 +5,9 @@ package s3
 import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/defaults"
+	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/service/serviceinfo"
 	"github.com/aws/aws-sdk-go/internal/protocol/restxml"
 	"github.com/aws/aws-sdk-go/internal/signer/v4"
 )
@@ -19,14 +21,16 @@ type S3 struct {
 var initService func(*service.Service)
 
 // Used for custom request initialization logic
-var initRequest func(*service.Request)
+var initRequest func(*request.Request)
 
 // New returns a new S3 client.
 func New(config *aws.Config) *S3 {
 	service := &service.Service{
-		Config:      defaults.DefaultConfig.Merge(config),
+		ServiceInfo: serviceinfo.ServiceInfo{
-		ServiceName: "s3",
+			Config:      defaults.DefaultConfig.Merge(config),
-		APIVersion:  "2006-03-01",
+			ServiceName: "s3",
+			APIVersion:  "2006-03-01",
+		},
 	}
 	service.Initialize()
 
@@ -47,8 +51,8 @@ func New(config *aws.Config) *S3 {
 
 // newRequest creates a new request for a S3 operation and runs any
 // custom request initialization.
-func (c *S3) newRequest(op *service.Operation, params, data interface{}) *service.Request {
+func (c *S3) newRequest(op *request.Operation, params, data interface{}) *request.Request {
-	req := service.NewRequest(c.Service, op, params, data)
+	req := c.NewRequest(op, params, data)
 
 	// Run custom request initialization if present
 	if initRequest != nil {

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/sse.go

@@ -6,12 +6,12 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/awsutil"
-	"github.com/aws/aws-sdk-go/aws/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 var errSSERequiresSSL = awserr.New("ConfigError", "cannot send SSE keys over HTTP.", nil)
 
-func validateSSERequiresSSL(r *service.Request) {
+func validateSSERequiresSSL(r *request.Request) {
 	if r.HTTPRequest.URL.Scheme != "https" {
 		p := awsutil.ValuesAtPath(r.Params, "SSECustomerKey||CopySourceSSECustomerKey")
 		if len(p) > 0 {
@@ -20,7 +20,7 @@ func validateSSERequiresSSL(r *service.Request) {
 	}
 }
 
-func computeSSEKeys(r *service.Request) {
+func computeSSEKeys(r *request.Request) {
 	headers := []string{
 		"x-amz-server-side-encryption-customer-key",
 		"x-amz-copy-source-server-side-encryption-customer-key",

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/sse_test.go

@@ -1,81 +0,0 @@
-package s3_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func TestSSECustomerKeyOverHTTPError(t *testing.T) {
-	s := s3.New(&aws.Config{DisableSSL: aws.Bool(true)})
-	req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{
-		Bucket:         aws.String("bucket"),
-		CopySource:     aws.String("bucket/source"),
-		Key:            aws.String("dest"),
-		SSECustomerKey: aws.String("key"),
-	})
-	err := req.Build()
-
-	assert.Error(t, err)
-	assert.Equal(t, "ConfigError", err.(awserr.Error).Code())
-	assert.Contains(t, err.(awserr.Error).Message(), "cannot send SSE keys over HTTP")
-}
-
-func TestCopySourceSSECustomerKeyOverHTTPError(t *testing.T) {
-	s := s3.New(&aws.Config{DisableSSL: aws.Bool(true)})
-	req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{
-		Bucket:     aws.String("bucket"),
-		CopySource: aws.String("bucket/source"),
-		Key:        aws.String("dest"),
-		CopySourceSSECustomerKey: aws.String("key"),
-	})
-	err := req.Build()
-
-	assert.Error(t, err)
-	assert.Equal(t, "ConfigError", err.(awserr.Error).Code())
-	assert.Contains(t, err.(awserr.Error).Message(), "cannot send SSE keys over HTTP")
-}
-
-func TestComputeSSEKeys(t *testing.T) {
-	s := s3.New(nil)
-	req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{
-		Bucket:                   aws.String("bucket"),
-		CopySource:               aws.String("bucket/source"),
-		Key:                      aws.String("dest"),
-		SSECustomerKey:           aws.String("key"),
-		CopySourceSSECustomerKey: aws.String("key"),
-	})
-	err := req.Build()
-
-	assert.NoError(t, err)
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"))
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"))
-	assert.Equal(t, "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"))
-	assert.Equal(t, "PG4LipwVIkqCKLmpjKFTHQ==", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"))
-}
-
-func TestComputeSSEKeysShortcircuit(t *testing.T) {
-	s := s3.New(nil)
-	req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{
-		Bucket:                      aws.String("bucket"),
-		CopySource:                  aws.String("bucket/source"),
-		Key:                         aws.String("dest"),
-		SSECustomerKey:              aws.String("key"),
-		CopySourceSSECustomerKey:    aws.String("key"),
-		SSECustomerKeyMD5:           aws.String("MD5"),
-		CopySourceSSECustomerKeyMD5: aws.String("MD5"),
-	})
-	err := req.Build()
-
-	assert.NoError(t, err)
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key"))
-	assert.Equal(t, "a2V5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key"))
-	assert.Equal(t, "MD5", req.HTTPRequest.Header.Get("x-amz-server-side-encryption-customer-key-md5"))
-	assert.Equal(t, "MD5", req.HTTPRequest.Header.Get("x-amz-copy-source-server-side-encryption-customer-key-md5"))
-}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/statusok_error.go

@@ -0,0 +1,36 @@
+package s3
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+func copyMultipartStatusOKUnmarhsalError(r *request.Request) {
+	b, err := ioutil.ReadAll(r.HTTPResponse.Body)
+	if err != nil {
+		r.Error = awserr.New("SerializationError", "unable to read response body", err)
+		return
+	}
+	body := bytes.NewReader(b)
+	r.HTTPResponse.Body = aws.ReadSeekCloser(body)
+	defer r.HTTPResponse.Body.(aws.ReaderSeekerCloser).Seek(0, 0)
+
+	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
+	}
+}

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/unmarshal_error.go

@@ -2,11 +2,14 @@ package s3
 
 import (
 	"encoding/xml"
+	"fmt"
 	"io"
+	"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/service"
+	"github.com/aws/aws-sdk-go/aws/request"
 )
 
 type xmlErrorResponse struct {
@@ -15,9 +18,15 @@ type xmlErrorResponse struct {
 	Message string   `xml:"Message"`
 }
 
-func unmarshalError(r *service.Request) {
+func unmarshalError(r *request.Request) {
 	defer r.HTTPResponse.Body.Close()
 
+	if r.HTTPResponse.StatusCode == http.StatusMovedPermanently {
+		r.Error = awserr.New("BucketRegionError",
+			fmt.Sprintf("incorrect region, the bucket is not in '%s' region", aws.StringValue(r.Service.Config.Region)), nil)
+		return
+	}
+
 	if r.HTTPResponse.ContentLength == int64(0) {
 		// No body, use status code to generate an awserr.Error
 		r.Error = awserr.NewRequestFailure(

Godeps/_workspace/src/github.com/aws/aws-sdk-go/service/s3/unmarshal_error_test.go

@@ -1,54 +0,0 @@
-package s3_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/service"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-var s3StatusCodeErrorTests = []struct {
-	scode   int
-	status  string
-	body    string
-	code    string
-	message string
-}{
-	{301, "Moved Permanently", "", "MovedPermanently", "Moved Permanently"},
-	{403, "Forbidden", "", "Forbidden", "Forbidden"},
-	{400, "Bad Request", "", "BadRequest", "Bad Request"},
-	{404, "Not Found", "", "NotFound", "Not Found"},
-	{500, "Internal Error", "", "InternalError", "Internal Error"},
-}
-
-func TestStatusCodeError(t *testing.T) {
-	for _, test := range s3StatusCodeErrorTests {
-		s := s3.New(nil)
-		s.Handlers.Send.Clear()
-		s.Handlers.Send.PushBack(func(r *service.Request) {
-			body := ioutil.NopCloser(bytes.NewReader([]byte(test.body)))
-			r.HTTPResponse = &http.Response{
-				ContentLength: int64(len(test.body)),
-				StatusCode:    test.scode,
-				Status:        test.status,
-				Body:          body,
-			}
-		})
-		_, err := s.PutBucketAcl(&s3.PutBucketAclInput{
-			Bucket: aws.String("bucket"), ACL: aws.String("public-read"),
-		})
-
-		assert.Error(t, err)
-		assert.Equal(t, test.code, err.(awserr.Error).Code())
-		assert.Equal(t, test.message, err.(awserr.Error).Message())
-	}
-}

Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/add_child_test.go

@@ -1,73 +0,0 @@
-package etcd
-
-import "testing"
-
-func TestAddChild(t *testing.T) {
-	c := NewClient(nil)
-	defer func() {
-		c.Delete("fooDir", true)
-		c.Delete("nonexistentDir", true)
-	}()
-
-	c.CreateDir("fooDir", 5)
-
-	_, err := c.AddChild("fooDir", "v0", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = c.AddChild("fooDir", "v1", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	resp, err := c.Get("fooDir", true, false)
-	// The child with v0 should proceed the child with v1 because it's added
-	// earlier, so it should have a lower key.
-	if !(len(resp.Node.Nodes) == 2 && (resp.Node.Nodes[0].Value == "v0" && resp.Node.Nodes[1].Value == "v1")) {
-		t.Fatalf("AddChild 1 failed.  There should be two chlidren whose values are v0 and v1, respectively."+
-			"  The response was: %#v", resp)
-	}
-
-	// Creating a child under a nonexistent directory should succeed.
-	// The directory should be created.
-	resp, err = c.AddChild("nonexistentDir", "foo", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestAddChildDir(t *testing.T) {
-	c := NewClient(nil)
-	defer func() {
-		c.Delete("fooDir", true)
-		c.Delete("nonexistentDir", true)
-	}()
-
-	c.CreateDir("fooDir", 5)
-
-	_, err := c.AddChildDir("fooDir", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = c.AddChildDir("fooDir", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	resp, err := c.Get("fooDir", true, false)
-	// The child with v0 should proceed the child with v1 because it's added
-	// earlier, so it should have a lower key.
-	if !(len(resp.Node.Nodes) == 2 && (len(resp.Node.Nodes[0].Nodes) == 0 && len(resp.Node.Nodes[1].Nodes) == 0)) {
-		t.Fatalf("AddChildDir 1 failed.  There should be two chlidren whose values are v0 and v1, respectively."+
-			"  The response was: %#v", resp)
-	}
-
-	// Creating a child under a nonexistent directory should succeed.
-	// The directory should be created.
-	resp, err = c.AddChildDir("nonexistentDir", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-}

Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/client_test.go

@@ -1,108 +0,0 @@
-package etcd
-
-import (
-	"encoding/json"
-	"fmt"
-	"net"
-	"net/url"
-	"os"
-	"testing"
-)
-
-// To pass this test, we need to create a cluster of 3 machines
-// The server should be listening on localhost:4001, 4002, 4003
-func TestSync(t *testing.T) {
-	fmt.Println("Make sure there are three nodes at 0.0.0.0:4001-4003")
-
-	// Explicit trailing slash to ensure this doesn't reproduce:
-	// https://github.com/coreos/go-etcd/issues/82
-	c := NewClient([]string{"http://127.0.0.1:4001/"})
-
-	success := c.SyncCluster()
-	if !success {
-		t.Fatal("cannot sync machines")
-	}
-
-	for _, m := range c.GetCluster() {
-		u, err := url.Parse(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if u.Scheme != "http" {
-			t.Fatal("scheme must be http")
-		}
-
-		host, _, err := net.SplitHostPort(u.Host)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if host != "localhost" {
-			t.Fatal("Host must be localhost")
-		}
-	}
-
-	badMachines := []string{"abc", "edef"}
-
-	success = c.SetCluster(badMachines)
-
-	if success {
-		t.Fatal("should not sync on bad machines")
-	}
-
-	goodMachines := []string{"127.0.0.1:4002"}
-
-	success = c.SetCluster(goodMachines)
-
-	if !success {
-		t.Fatal("cannot sync machines")
-	} else {
-		fmt.Println(c.cluster.Machines)
-	}
-
-}
-
-func TestPersistence(t *testing.T) {
-	c := NewClient(nil)
-	c.SyncCluster()
-
-	fo, err := os.Create("config.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() {
-		if err := fo.Close(); err != nil {
-			panic(err)
-		}
-	}()
-
-	c.SetPersistence(fo)
-	err = c.saveConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	c2, err := NewClientFromFile("config.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Verify that the two clients have the same config
-	b1, _ := json.Marshal(c)
-	b2, _ := json.Marshal(c2)
-
-	if string(b1) != string(b2) {
-		t.Fatalf("The two configs should be equal!")
-	}
-}
-
-func TestClientRetry(t *testing.T) {
-	c := NewClient([]string{"http://strange", "http://127.0.0.1:4001"})
-	// use first endpoint as the picked url
-	c.cluster.picked = 0
-	if _, err := c.Set("foo", "bar", 5); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := c.Delete("foo", true); err != nil {
-		t.Fatal(err)
-	}
-}

Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_delete_test.go

@@ -1,46 +0,0 @@
-package etcd
-
-import (
-	"testing"
-)
-
-func TestCompareAndDelete(t *testing.T) {
-	c := NewClient(nil)
-	defer func() {
-		c.Delete("foo", true)
-	}()
-
-	c.Set("foo", "bar", 5)
-
-	// This should succeed an correct prevValue
-	resp, err := c.CompareAndDelete("foo", "bar", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
-		t.Fatalf("CompareAndDelete 1 prevNode failed: %#v", resp)
-	}
-
-	resp, _ = c.Set("foo", "bar", 5)
-	// This should fail because it gives an incorrect prevValue
-	_, err = c.CompareAndDelete("foo", "xxx", 0)
-	if err == nil {
-		t.Fatalf("CompareAndDelete 2 should have failed.  The response is: %#v", resp)
-	}
-
-	// This should succeed because it gives an correct prevIndex
-	resp, err = c.CompareAndDelete("foo", "", resp.Node.ModifiedIndex)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
-		t.Fatalf("CompareAndSwap 3 prevNode failed: %#v", resp)
-	}
-
-	c.Set("foo", "bar", 5)
-	// This should fail because it gives an incorrect prevIndex
-	resp, err = c.CompareAndDelete("foo", "", 29817514)
-	if err == nil {
-		t.Fatalf("CompareAndDelete 4 should have failed.  The response is: %#v", resp)
-	}
-}

Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go

@@ -1,57 +0,0 @@
-package etcd
-
-import (
-	"testing"
-)
-
-func TestCompareAndSwap(t *testing.T) {
-	c := NewClient(nil)
-	defer func() {
-		c.Delete("foo", true)
-	}()
-
-	c.Set("foo", "bar", 5)
-
-	// This should succeed
-	resp, err := c.CompareAndSwap("foo", "bar2", 5, "bar", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !(resp.Node.Value == "bar2" && resp.Node.Key == "/foo" && resp.Node.TTL == 5) {
-		t.Fatalf("CompareAndSwap 1 failed: %#v", resp)
-	}
-
-	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
-		t.Fatalf("CompareAndSwap 1 prevNode failed: %#v", resp)
-	}
-
-	// This should fail because it gives an incorrect prevValue
-	resp, err = c.CompareAndSwap("foo", "bar3", 5, "xxx", 0)
-	if err == nil {
-		t.Fatalf("CompareAndSwap 2 should have failed.  The response is: %#v", resp)
-	}
-
-	resp, err = c.Set("foo", "bar", 5)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// This should succeed
-	resp, err = c.CompareAndSwap("foo", "bar2", 5, "", resp.Node.ModifiedIndex)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !(resp.Node.Value == "bar2" && resp.Node.Key == "/foo" && resp.Node.TTL == 5) {
-		t.Fatalf("CompareAndSwap 3 failed: %#v", resp)
-	}
-
-	if !(resp.PrevNode.Value == "bar" && resp.PrevNode.Key == "/foo" && resp.PrevNode.TTL == 5) {
-		t.Fatalf("CompareAndSwap 3 prevNode failed: %#v", resp)
-	}
-
-	// This should fail because it gives an incorrect prevIndex
-	resp, err = c.CompareAndSwap("foo", "bar3", 5, "", 29817514)
-	if err == nil {
-		t.Fatalf("CompareAndSwap 4 should have failed.  The response is: %#v", resp)
-	}
-}