diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index c3b67b69c39..e509ba1d68c 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -61,7 +61,7 @@
"Rev": "c0a38f106248742920a2b786dcae81457af003d3"
},
{
- "ImportPath": "github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil",
+ "ImportPath": "github.com/awslabs/aws-sdk-go/internal/protocol/query",
"Rev": "c0a38f106248742920a2b786dcae81457af003d3"
},
{
@@ -76,6 +76,10 @@
"ImportPath": "github.com/awslabs/aws-sdk-go/service/ec2",
"Rev": "c0a38f106248742920a2b786dcae81457af003d3"
},
+ {
+ "ImportPath": "github.com/awslabs/aws-sdk-go/service/elb",
+ "Rev": "c0a38f106248742920a2b786dcae81457af003d3"
+ },
{
"ImportPath": "github.com/beorn7/perks/quantile",
"Rev": "b965b613227fddccbfffe13eae360ed3fa822f8d"
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go
new file mode 100644
index 00000000000..36a473c38b9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build.go
@@ -0,0 +1,31 @@
+package query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/query.json build_test.go
+
+import (
+ "net/url"
+
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/query/queryutil"
+)
+
+// Build builds a request for an AWS Query service.
+func Build(r *aws.Request) {
+ body := url.Values{
+ "Action": {r.Operation.Name},
+ "Version": {r.Service.APIVersion},
+ }
+ if err := queryutil.Parse(body, r.Params, false); err != nil {
+ r.Error = err
+ return
+ }
+
+ if r.ExpireTime == 0 {
+ r.HTTPRequest.Method = "POST"
+ r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
+ r.SetBufferBody([]byte(body.Encode()))
+ } else { // This is a pre-signed request
+ r.HTTPRequest.Method = "GET"
+ r.HTTPRequest.URL.RawQuery = body.Encode()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go
new file mode 100644
index 00000000000..284b96134c7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/build_test.go
@@ -0,0 +1,1596 @@
+package query_test
+
+import (
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/query"
+ "github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+ "github.com/awslabs/aws-sdk-go/internal/util"
+ "github.com/stretchr/testify/assert"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "testing"
+ "time"
+)
+
+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
+
+// InputService1ProtocolTest is a client for InputService1ProtocolTest.
+type InputService1ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService1ProtocolTest client.
+func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice1protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService1ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService1ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
+
+ if opInputService1TestCaseOperation1 == nil {
+ opInputService1TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService1TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService1TestCaseOperation1, input, output)
+ output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (output *InputService1TestShapeInputService1TestCaseOperation1Output, err error) {
+ req, out := c.InputService1TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService1TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// InputService2ProtocolTest is a client for InputService2ProtocolTest.
+type InputService2ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService2ProtocolTest client.
+func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice2protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService2ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService2ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
+
+ if opInputService2TestCaseOperation1 == nil {
+ opInputService2TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService2TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService2TestCaseOperation1, input, output)
+ output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (output *InputService2TestShapeInputService2TestCaseOperation1Output, err error) {
+ req, out := c.InputService2TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService2TestCaseOperation1 *aws.Operation
+
+type InputService2TestShapeInputService2TestCaseOperation1Output struct {
+ metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeInputShape struct {
+ StructArg *InputService2TestShapeStructType `type:"structure"`
+
+ metadataInputService2TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService2TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService2TestShapeStructType struct {
+ ScalarArg *string `type:"string"`
+
+ metadataInputService2TestShapeStructType `json:"-" xml:"-"`
+}
+
+type metadataInputService2TestShapeStructType struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService3ProtocolTest is a client for InputService3ProtocolTest.
+type InputService3ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService3ProtocolTest client.
+func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice3protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService3ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService3ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
+
+ if opInputService3TestCaseOperation1 == nil {
+ opInputService3TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService3TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService3TestCaseOperation1, input, output)
+ output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (output *InputService3TestShapeInputService3TestCaseOperation1Output, err error) {
+ req, out := c.InputService3TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService3TestCaseOperation1 *aws.Operation
+
+// InputService3TestCaseOperation2Request generates a request for the InputService3TestCaseOperation2 operation.
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) {
+
+ if opInputService3TestCaseOperation2 == nil {
+ opInputService3TestCaseOperation2 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService3TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService3TestCaseOperation2, input, output)
+ output = &InputService3TestShapeInputService3TestCaseOperation2Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputShape) (output *InputService3TestShapeInputService3TestCaseOperation2Output, err error) {
+ req, out := c.InputService3TestCaseOperation2Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService3TestCaseOperation2 *aws.Operation
+
+type InputService3TestShapeInputService3TestCaseOperation1Output struct {
+ metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeInputService3TestCaseOperation2Output struct {
+ metadataInputService3TestShapeInputService3TestCaseOperation2Output `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeInputService3TestCaseOperation2Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService3TestShapeInputShape struct {
+ ListArg []*string `type:"list"`
+
+ metadataInputService3TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService3TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService4ProtocolTest is a client for InputService4ProtocolTest.
+type InputService4ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService4ProtocolTest client.
+func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice4protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService4ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService4ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
+
+ if opInputService4TestCaseOperation1 == nil {
+ opInputService4TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService4TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService4TestCaseOperation1, input, output)
+ output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (output *InputService4TestShapeInputService4TestCaseOperation1Output, err error) {
+ req, out := c.InputService4TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService4TestCaseOperation1 *aws.Operation
+
+// InputService4TestCaseOperation2Request generates a request for the InputService4TestCaseOperation2 operation.
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation2Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation2Output) {
+
+ if opInputService4TestCaseOperation2 == nil {
+ opInputService4TestCaseOperation2 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService4TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService4TestCaseOperation2, input, output)
+ output = &InputService4TestShapeInputService4TestCaseOperation2Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService4ProtocolTest) InputService4TestCaseOperation2(input *InputService4TestShapeInputShape) (output *InputService4TestShapeInputService4TestCaseOperation2Output, err error) {
+ req, out := c.InputService4TestCaseOperation2Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService4TestCaseOperation2 *aws.Operation
+
+type InputService4TestShapeInputService4TestCaseOperation1Output struct {
+ metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4TestShapeInputService4TestCaseOperation2Output struct {
+ metadataInputService4TestShapeInputService4TestCaseOperation2Output `json:"-" xml:"-"`
+}
+
+type metadataInputService4TestShapeInputService4TestCaseOperation2Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService4TestShapeInputShape struct {
+ ListArg []*string `type:"list" flattened:"true"`
+
+ ScalarArg *string `type:"string"`
+
+ metadataInputService4TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService4TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService5ProtocolTest is a client for InputService5ProtocolTest.
+type InputService5ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService5ProtocolTest client.
+func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice5protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService5ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService5ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
+
+ if opInputService5TestCaseOperation1 == nil {
+ opInputService5TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService5TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService5TestCaseOperation1, input, output)
+ output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (output *InputService5TestShapeInputService5TestCaseOperation1Output, err error) {
+ req, out := c.InputService5TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService5TestCaseOperation1 *aws.Operation
+
+// InputService5TestCaseOperation2Request generates a request for the InputService5TestCaseOperation2 operation.
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation2Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation2Output) {
+
+ if opInputService5TestCaseOperation2 == nil {
+ opInputService5TestCaseOperation2 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService5TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService5TestCaseOperation2, input, output)
+ output = &InputService5TestShapeInputService5TestCaseOperation2Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService5ProtocolTest) InputService5TestCaseOperation2(input *InputService5TestShapeInputShape) (output *InputService5TestShapeInputService5TestCaseOperation2Output, err error) {
+ req, out := c.InputService5TestCaseOperation2Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService5TestCaseOperation2 *aws.Operation
+
+type InputService5TestShapeInputService5TestCaseOperation1Output struct {
+ metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5TestShapeInputService5TestCaseOperation2Output struct {
+ metadataInputService5TestShapeInputService5TestCaseOperation2Output `json:"-" xml:"-"`
+}
+
+type metadataInputService5TestShapeInputService5TestCaseOperation2Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService5TestShapeInputShape struct {
+ MapArg *map[string]*string `type:"map"`
+
+ metadataInputService5TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService5TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService6ProtocolTest is a client for InputService6ProtocolTest.
+type InputService6ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService6ProtocolTest client.
+func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice6protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService6ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService6ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
+
+ if opInputService6TestCaseOperation1 == nil {
+ opInputService6TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService6TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService6TestCaseOperation1, input, output)
+ output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (output *InputService6TestShapeInputService6TestCaseOperation1Output, err error) {
+ req, out := c.InputService6TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService6TestCaseOperation1 *aws.Operation
+
+type InputService6TestShapeInputService6TestCaseOperation1Output struct {
+ metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService6TestShapeInputShape struct {
+ MapArg *map[string]*string `locationNameKey:"TheKey" locationNameValue:"TheValue" type:"map"`
+
+ metadataInputService6TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService6TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// InputService7ProtocolTest is a client for InputService7ProtocolTest.
+type InputService7ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService7ProtocolTest client.
+func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice7protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService7ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService7ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
+
+ if opInputService7TestCaseOperation1 == nil {
+ opInputService7TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService7TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService7TestCaseOperation1, input, output)
+ output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (output *InputService7TestShapeInputService7TestCaseOperation1Output, err error) {
+ req, out := c.InputService7TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService7TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// InputService8ProtocolTest is a client for InputService8ProtocolTest.
+type InputService8ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService8ProtocolTest client.
+func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice8protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService8ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService8ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
+
+ if opInputService8TestCaseOperation1 == nil {
+ opInputService8TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService8TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService8TestCaseOperation1, input, output)
+ output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (output *InputService8TestShapeInputService8TestCaseOperation1Output, err error) {
+ req, out := c.InputService8TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService8TestCaseOperation1 *aws.Operation
+
+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"`
+}
+
+// InputService9ProtocolTest is a client for InputService9ProtocolTest.
+type InputService9ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new InputService9ProtocolTest client.
+func NewInputService9ProtocolTest(config *aws.Config) *InputService9ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "inputservice9protocoltest",
+ APIVersion: "2014-01-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &InputService9ProtocolTest{service}
+}
+
+// newRequest creates a new request for a InputService9ProtocolTest operation and runs any
+// custom request initialization.
+func (c *InputService9ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// InputService9TestCaseOperation1Request generates a request for the InputService9TestCaseOperation1 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) {
+
+ if opInputService9TestCaseOperation1 == nil {
+ opInputService9TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation1, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation1Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation1Output, err error) {
+ req, out := c.InputService9TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation1 *aws.Operation
+
+// InputService9TestCaseOperation2Request generates a request for the InputService9TestCaseOperation2 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) {
+
+ if opInputService9TestCaseOperation2 == nil {
+ opInputService9TestCaseOperation2 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation2, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation2Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation2Output, err error) {
+ req, out := c.InputService9TestCaseOperation2Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation2 *aws.Operation
+
+// InputService9TestCaseOperation3Request generates a request for the InputService9TestCaseOperation3 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation3Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation3Output) {
+
+ if opInputService9TestCaseOperation3 == nil {
+ opInputService9TestCaseOperation3 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation3, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation3Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation3(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation3Output, err error) {
+ req, out := c.InputService9TestCaseOperation3Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation3 *aws.Operation
+
+// InputService9TestCaseOperation4Request generates a request for the InputService9TestCaseOperation4 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation4Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation4Output) {
+
+ if opInputService9TestCaseOperation4 == nil {
+ opInputService9TestCaseOperation4 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation4, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation4Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation4(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation4Output, err error) {
+ req, out := c.InputService9TestCaseOperation4Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation4 *aws.Operation
+
+// InputService9TestCaseOperation5Request generates a request for the InputService9TestCaseOperation5 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation5Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation5Output) {
+
+ if opInputService9TestCaseOperation5 == nil {
+ opInputService9TestCaseOperation5 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation5, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation5Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation5(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation5Output, err error) {
+ req, out := c.InputService9TestCaseOperation5Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation5 *aws.Operation
+
+// InputService9TestCaseOperation6Request generates a request for the InputService9TestCaseOperation6 operation.
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation6Request(input *InputService9TestShapeInputShape) (req *aws.Request, output *InputService9TestShapeInputService9TestCaseOperation6Output) {
+
+ if opInputService9TestCaseOperation6 == nil {
+ opInputService9TestCaseOperation6 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &InputService9TestShapeInputShape{}
+ }
+
+ req = c.newRequest(opInputService9TestCaseOperation6, input, output)
+ output = &InputService9TestShapeInputService9TestCaseOperation6Output{}
+ req.Data = output
+ return
+}
+
+func (c *InputService9ProtocolTest) InputService9TestCaseOperation6(input *InputService9TestShapeInputShape) (output *InputService9TestShapeInputService9TestCaseOperation6Output, err error) {
+ req, out := c.InputService9TestCaseOperation6Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opInputService9TestCaseOperation6 *aws.Operation
+
+type InputService9TestShapeInputService9TestCaseOperation1Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation1Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation1Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputService9TestCaseOperation2Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation2Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation2Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputService9TestCaseOperation3Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation3Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation3Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputService9TestCaseOperation4Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation4Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation4Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputService9TestCaseOperation5Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation5Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation5Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputService9TestCaseOperation6Output struct {
+ metadataInputService9TestShapeInputService9TestCaseOperation6Output `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputService9TestCaseOperation6Output struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeInputShape struct {
+ RecursiveStruct *InputService9TestShapeRecursiveStructType `type:"structure"`
+
+ metadataInputService9TestShapeInputShape `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeInputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type InputService9TestShapeRecursiveStructType struct {
+ NoRecurse *string `type:"string"`
+
+ RecursiveList []*InputService9TestShapeRecursiveStructType `type:"list"`
+
+ RecursiveMap *map[string]*InputService9TestShapeRecursiveStructType `type:"map"`
+
+ RecursiveStruct *InputService9TestShapeRecursiveStructType `type:"structure"`
+
+ metadataInputService9TestShapeRecursiveStructType `json:"-" xml:"-"`
+}
+
+type metadataInputService9TestShapeRecursiveStructType 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
+ query.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 TestInputService2ProtocolTestNestedStructureMembersCase1(t *testing.T) {
+ svc := NewInputService2ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService2TestShapeInputShape{
+ StructArg: &InputService2TestShapeStructType{
+ ScalarArg: aws.String("foo"),
+ },
+ }
+ req, _ := svc.InputService2TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&StructArg.ScalarArg=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService3ProtocolTestListTypesCase1(t *testing.T) {
+ svc := NewInputService3ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService3TestShapeInputShape{
+ ListArg: []*string{
+ aws.String("foo"),
+ aws.String("bar"),
+ aws.String("baz"),
+ },
+ }
+ req, _ := svc.InputService3TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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.member.1=foo&ListArg.member.2=bar&ListArg.member.3=baz&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService3ProtocolTestListTypesCase2(t *testing.T) {
+ svc := NewInputService3ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService3TestShapeInputShape{
+ ListArg: []*string{},
+ }
+ req, _ := svc.InputService3TestCaseOperation2Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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=&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService4ProtocolTestFlattenedListCase1(t *testing.T) {
+ svc := NewInputService4ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService4TestShapeInputShape{
+ ListArg: []*string{
+ aws.String("a"),
+ aws.String("b"),
+ aws.String("c"),
+ },
+ ScalarArg: aws.String("foo"),
+ }
+ req, _ := svc.InputService4TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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=a&ListArg.2=b&ListArg.3=c&ScalarArg=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService4ProtocolTestFlattenedListCase2(t *testing.T) {
+ svc := NewInputService4ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService4TestShapeInputShape{
+ ListArg: []*string{},
+ ScalarArg: aws.String("foo"),
+ }
+ req, _ := svc.InputService4TestCaseOperation2Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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=&ScalarArg=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService5ProtocolTestSerializeMapTypeCase1(t *testing.T) {
+ svc := NewInputService5ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService5TestShapeInputShape{
+ MapArg: &map[string]*string{
+ "key1": aws.String("val1"),
+ "key2": aws.String("val2"),
+ },
+ }
+ req, _ := svc.InputService5TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&MapArg.entry.1.key=key1&MapArg.entry.1.value=val1&MapArg.entry.2.key=key2&MapArg.entry.2.value=val2&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService5ProtocolTestSerializeMapTypeCase2(t *testing.T) {
+ svc := NewInputService5ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService5TestShapeInputShape{
+ MapArg: &map[string]*string{},
+ }
+ req, _ := svc.InputService5TestCaseOperation2Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&MapArg=&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService6ProtocolTestSerializeMapTypeWithLocationNameCase1(t *testing.T) {
+ svc := NewInputService6ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService6TestShapeInputShape{
+ MapArg: &map[string]*string{
+ "key1": aws.String("val1"),
+ "key2": aws.String("val2"),
+ },
+ }
+ req, _ := svc.InputService6TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&MapArg.entry.1.TheKey=key1&MapArg.entry.1.TheValue=val1&MapArg.entry.2.TheKey=key2&MapArg.entry.2.TheValue=val2&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
+ query.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
+ query.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
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase1(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation1Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase2(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation2Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase3(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ },
+ },
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation3Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.RecursiveStruct.RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase4(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveList: []*InputService9TestShapeRecursiveStructType{
+ &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("bar"),
+ },
+ },
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation4Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.NoRecurse=bar&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase5(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveList: []*InputService9TestShapeRecursiveStructType{
+ &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ &InputService9TestShapeRecursiveStructType{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("bar"),
+ },
+ },
+ },
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation5Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.RecursiveStruct.NoRecurse=bar&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
+func TestInputService9ProtocolTestRecursiveShapesCase6(t *testing.T) {
+ svc := NewInputService9ProtocolTest(nil)
+ svc.Endpoint = "https://test"
+
+ input := &InputService9TestShapeInputShape{
+ RecursiveStruct: &InputService9TestShapeRecursiveStructType{
+ RecursiveMap: &map[string]*InputService9TestShapeRecursiveStructType{
+ "bar": &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("bar"),
+ },
+ "foo": &InputService9TestShapeRecursiveStructType{
+ NoRecurse: aws.String("foo"),
+ },
+ },
+ },
+ }
+ req, _ := svc.InputService9TestCaseOperation6Request(input)
+ r := req.HTTPRequest
+
+ // build request
+ query.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&RecursiveStruct.RecursiveMap.entry.1.key=bar&RecursiveStruct.RecursiveMap.entry.1.value.NoRecurse=bar&RecursiveStruct.RecursiveMap.entry.2.key=foo&RecursiveStruct.RecursiveMap.entry.2.value.NoRecurse=foo&Version=2014-01-01`), util.Trim(string(body)))
+
+ // assert URL
+ assert.Equal(t, "https://test/", r.URL.String())
+
+ // assert headers
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go
new file mode 100644
index 00000000000..fde5e131ae1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal.go
@@ -0,0 +1,28 @@
+package query
+
+//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/query.json unmarshal_test.go
+
+import (
+ "encoding/xml"
+
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+)
+
+// Unmarshal unmarshals a response for an AWS Query service.
+func Unmarshal(r *aws.Request) {
+ defer r.HTTPResponse.Body.Close()
+ if r.DataFilled() {
+ decoder := xml.NewDecoder(r.HTTPResponse.Body)
+ err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")
+ if err != nil {
+ r.Error = err
+ return
+ }
+ }
+}
+
+// UnmarshalMeta unmarshals header response values for an AWS Query service.
+func UnmarshalMeta(r *aws.Request) {
+ // TODO implement unmarshaling of request IDs
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go
new file mode 100644
index 00000000000..caa4b9c02c9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_error.go
@@ -0,0 +1,32 @@
+package query
+
+import (
+ "encoding/xml"
+ "io"
+
+ "github.com/awslabs/aws-sdk-go/aws"
+)
+
+type xmlErrorResponse struct {
+ XMLName xml.Name `xml:"ErrorResponse"`
+ Code string `xml:"Error>Code"`
+ Message string `xml:"Error>Message"`
+ RequestID string `xml:"RequestId"`
+}
+
+// UnmarshalError unmarshals an error response for an AWS Query service.
+func UnmarshalError(r *aws.Request) {
+ defer r.HTTPResponse.Body.Close()
+
+ resp := &xmlErrorResponse{}
+ err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
+ if err != nil && err != io.EOF {
+ r.Error = err
+ } else {
+ r.Error = aws.APIError{
+ StatusCode: r.HTTPResponse.StatusCode,
+ Code: resp.Code,
+ Message: resp.Message,
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go
new file mode 100644
index 00000000000..a0f82c662fa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/internal/protocol/query/unmarshal_test.go
@@ -0,0 +1,1545 @@
+package query_test
+
+import (
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/query"
+ "github.com/awslabs/aws-sdk-go/internal/signer/v4"
+
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
+ "github.com/awslabs/aws-sdk-go/internal/util"
+ "github.com/stretchr/testify/assert"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "testing"
+ "time"
+)
+
+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
+
+// OutputService1ProtocolTest is a client for OutputService1ProtocolTest.
+type OutputService1ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService1ProtocolTest client.
+func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice1protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService1ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService1ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
+
+ if opOutputService1TestCaseOperation1 == nil {
+ opOutputService1TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService1TestCaseOperation1, input, output)
+ output = &OutputService1TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (output *OutputService1TestShapeOutputShape, err error) {
+ req, out := c.OutputService1TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService1TestCaseOperation1 *aws.Operation
+
+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"`
+
+ Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+ TrueBool *bool `type:"boolean"`
+
+ metadataOutputService1TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService1TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService2ProtocolTest is a client for OutputService2ProtocolTest.
+type OutputService2ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService2ProtocolTest client.
+func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice2protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService2ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
+
+ if opOutputService2TestCaseOperation1 == nil {
+ opOutputService2TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService2TestCaseOperation1, input, output)
+ output = &OutputService2TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (output *OutputService2TestShapeOutputShape, err error) {
+ req, out := c.OutputService2TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService2TestCaseOperation1 *aws.Operation
+
+type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+ metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService2TestShapeOutputShape struct {
+ Num *int64 `type:"integer"`
+
+ Str *string `type:"string"`
+
+ metadataOutputService2TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService2TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService3ProtocolTest is a client for OutputService3ProtocolTest.
+type OutputService3ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService3ProtocolTest client.
+func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice3protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService3ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
+
+ if opOutputService3TestCaseOperation1 == nil {
+ opOutputService3TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService3TestCaseOperation1, input, output)
+ output = &OutputService3TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (output *OutputService3TestShapeOutputShape, err error) {
+ req, out := c.OutputService3TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService3TestCaseOperation1 *aws.Operation
+
+type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+ metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService3TestShapeOutputShape struct {
+ Blob []byte `type:"blob"`
+
+ metadataOutputService3TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService3TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService4ProtocolTest is a client for OutputService4ProtocolTest.
+type OutputService4ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService4ProtocolTest client.
+func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice4protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService4ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
+
+ if opOutputService4TestCaseOperation1 == nil {
+ opOutputService4TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService4TestCaseOperation1, input, output)
+ output = &OutputService4TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (output *OutputService4TestShapeOutputShape, err error) {
+ req, out := c.OutputService4TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService4TestCaseOperation1 *aws.Operation
+
+type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+ metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService4TestShapeOutputShape struct {
+ ListMember []*string `type:"list"`
+
+ metadataOutputService4TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService4TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService5ProtocolTest is a client for OutputService5ProtocolTest.
+type OutputService5ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService5ProtocolTest client.
+func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice5protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService5ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
+
+ if opOutputService5TestCaseOperation1 == nil {
+ opOutputService5TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService5TestCaseOperation1, input, output)
+ output = &OutputService5TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (output *OutputService5TestShapeOutputShape, err error) {
+ req, out := c.OutputService5TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService5TestCaseOperation1 *aws.Operation
+
+type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+ metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService5TestShapeOutputShape struct {
+ ListMember []*string `locationNameList:"item" type:"list"`
+
+ metadataOutputService5TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService5TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService6ProtocolTest is a client for OutputService6ProtocolTest.
+type OutputService6ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService6ProtocolTest client.
+func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice6protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService6ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
+
+ if opOutputService6TestCaseOperation1 == nil {
+ opOutputService6TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService6TestCaseOperation1, input, output)
+ output = &OutputService6TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (output *OutputService6TestShapeOutputShape, err error) {
+ req, out := c.OutputService6TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService6TestCaseOperation1 *aws.Operation
+
+type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+ metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService6TestShapeOutputShape struct {
+ ListMember []*string `type:"list" flattened:"true"`
+
+ metadataOutputService6TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService6TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService7ProtocolTest is a client for OutputService7ProtocolTest.
+type OutputService7ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService7ProtocolTest client.
+func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice7protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService7ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
+
+ if opOutputService7TestCaseOperation1 == nil {
+ opOutputService7TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService7TestCaseOperation1, input, output)
+ output = &OutputService7TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (output *OutputService7TestShapeOutputShape, err error) {
+ req, out := c.OutputService7TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService7TestCaseOperation1 *aws.Operation
+
+type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+ metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService7TestShapeOutputShape struct {
+ ListMember []*string `type:"list" flattened:"true"`
+
+ metadataOutputService7TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService7TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService8ProtocolTest is a client for OutputService8ProtocolTest.
+type OutputService8ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService8ProtocolTest client.
+func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice8protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService8ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
+
+ if opOutputService8TestCaseOperation1 == nil {
+ opOutputService8TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService8TestCaseOperation1, input, output)
+ output = &OutputService8TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (output *OutputService8TestShapeOutputShape, err error) {
+ req, out := c.OutputService8TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService8TestCaseOperation1 *aws.Operation
+
+type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+ metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8TestShapeOutputShape struct {
+ List []*OutputService8TestShapeStructureShape `type:"list"`
+
+ metadataOutputService8TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService8TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService8TestShapeStructureShape struct {
+ Bar *string `type:"string"`
+
+ Baz *string `type:"string"`
+
+ Foo *string `type:"string"`
+
+ metadataOutputService8TestShapeStructureShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService8TestShapeStructureShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService9ProtocolTest is a client for OutputService9ProtocolTest.
+type OutputService9ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService9ProtocolTest client.
+func NewOutputService9ProtocolTest(config *aws.Config) *OutputService9ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice9protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService9ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService9ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService9ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService9TestCaseOperation1Request generates a request for the OutputService9TestCaseOperation1 operation.
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (req *aws.Request, output *OutputService9TestShapeOutputShape) {
+
+ if opOutputService9TestCaseOperation1 == nil {
+ opOutputService9TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService9TestShapeOutputService9TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService9TestCaseOperation1, input, output)
+ output = &OutputService9TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (output *OutputService9TestShapeOutputShape, err error) {
+ req, out := c.OutputService9TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService9TestCaseOperation1 *aws.Operation
+
+type OutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+ metadataOutputService9TestShapeOutputService9TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputService9TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService9TestShapeOutputShape struct {
+ List []*OutputService9TestShapeStructureShape `type:"list" flattened:"true"`
+
+ metadataOutputService9TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService9TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService9TestShapeStructureShape struct {
+ Bar *string `type:"string"`
+
+ Baz *string `type:"string"`
+
+ Foo *string `type:"string"`
+
+ metadataOutputService9TestShapeStructureShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService9TestShapeStructureShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService10ProtocolTest is a client for OutputService10ProtocolTest.
+type OutputService10ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService10ProtocolTest client.
+func NewOutputService10ProtocolTest(config *aws.Config) *OutputService10ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice10protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService10ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService10ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService10ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService10TestCaseOperation1Request generates a request for the OutputService10TestCaseOperation1 operation.
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (req *aws.Request, output *OutputService10TestShapeOutputShape) {
+
+ if opOutputService10TestCaseOperation1 == nil {
+ opOutputService10TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService10TestShapeOutputService10TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService10TestCaseOperation1, input, output)
+ output = &OutputService10TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (output *OutputService10TestShapeOutputShape, err error) {
+ req, out := c.OutputService10TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService10TestCaseOperation1 *aws.Operation
+
+type OutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+ metadataOutputService10TestShapeOutputService10TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputService10TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService10TestShapeOutputShape struct {
+ List []*string `locationNameList:"NamedList" type:"list" flattened:"true"`
+
+ metadataOutputService10TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService10TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService11ProtocolTest is a client for OutputService11ProtocolTest.
+type OutputService11ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService11ProtocolTest client.
+func NewOutputService11ProtocolTest(config *aws.Config) *OutputService11ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice11protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService11ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService11ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService11ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService11TestCaseOperation1Request generates a request for the OutputService11TestCaseOperation1 operation.
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (req *aws.Request, output *OutputService11TestShapeOutputShape) {
+
+ if opOutputService11TestCaseOperation1 == nil {
+ opOutputService11TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService11TestShapeOutputService11TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService11TestCaseOperation1, input, output)
+ output = &OutputService11TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (output *OutputService11TestShapeOutputShape, err error) {
+ req, out := c.OutputService11TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService11TestCaseOperation1 *aws.Operation
+
+type OutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+ metadataOutputService11TestShapeOutputService11TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputService11TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService11TestShapeOutputShape struct {
+ Map *map[string]*OutputService11TestShapeStructType `type:"map"`
+
+ metadataOutputService11TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService11TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService11TestShapeStructType struct {
+ Foo *string `locationName:"foo" type:"string"`
+
+ metadataOutputService11TestShapeStructType `json:"-" xml:"-"`
+}
+
+type metadataOutputService11TestShapeStructType struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService12ProtocolTest is a client for OutputService12ProtocolTest.
+type OutputService12ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService12ProtocolTest client.
+func NewOutputService12ProtocolTest(config *aws.Config) *OutputService12ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice12protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService12ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService12ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService12ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService12TestCaseOperation1Request generates a request for the OutputService12TestCaseOperation1 operation.
+func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1Request(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (req *aws.Request, output *OutputService12TestShapeOutputShape) {
+
+ if opOutputService12TestCaseOperation1 == nil {
+ opOutputService12TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService12TestShapeOutputService12TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService12TestCaseOperation1, input, output)
+ output = &OutputService12TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (output *OutputService12TestShapeOutputShape, err error) {
+ req, out := c.OutputService12TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService12TestCaseOperation1 *aws.Operation
+
+type OutputService12TestShapeOutputService12TestCaseOperation1Input struct {
+ metadataOutputService12TestShapeOutputService12TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService12TestShapeOutputService12TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService12TestShapeOutputShape struct {
+ Map *map[string]*string `type:"map" flattened:"true"`
+
+ metadataOutputService12TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService12TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService13ProtocolTest is a client for OutputService13ProtocolTest.
+type OutputService13ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService13ProtocolTest client.
+func NewOutputService13ProtocolTest(config *aws.Config) *OutputService13ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice13protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService13ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService13ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService13ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService13TestCaseOperation1Request generates a request for the OutputService13TestCaseOperation1 operation.
+func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1Request(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (req *aws.Request, output *OutputService13TestShapeOutputShape) {
+
+ if opOutputService13TestCaseOperation1 == nil {
+ opOutputService13TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService13TestShapeOutputService13TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService13TestCaseOperation1, input, output)
+ output = &OutputService13TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (output *OutputService13TestShapeOutputShape, err error) {
+ req, out := c.OutputService13TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService13TestCaseOperation1 *aws.Operation
+
+type OutputService13TestShapeOutputService13TestCaseOperation1Input struct {
+ metadataOutputService13TestShapeOutputService13TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService13TestShapeOutputService13TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService13TestShapeOutputShape struct {
+ Map *map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`
+
+ metadataOutputService13TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService13TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// OutputService14ProtocolTest is a client for OutputService14ProtocolTest.
+type OutputService14ProtocolTest struct {
+ *aws.Service
+}
+
+// New returns a new OutputService14ProtocolTest client.
+func NewOutputService14ProtocolTest(config *aws.Config) *OutputService14ProtocolTest {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "outputservice14protocoltest",
+ APIVersion: "",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ return &OutputService14ProtocolTest{service}
+}
+
+// newRequest creates a new request for a OutputService14ProtocolTest operation and runs any
+// custom request initialization.
+func (c *OutputService14ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ return req
+}
+
+// OutputService14TestCaseOperation1Request generates a request for the OutputService14TestCaseOperation1 operation.
+func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1Request(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (req *aws.Request, output *OutputService14TestShapeOutputShape) {
+
+ if opOutputService14TestCaseOperation1 == nil {
+ opOutputService14TestCaseOperation1 = &aws.Operation{
+ Name: "OperationName",
+ }
+ }
+
+ if input == nil {
+ input = &OutputService14TestShapeOutputService14TestCaseOperation1Input{}
+ }
+
+ req = c.newRequest(opOutputService14TestCaseOperation1, input, output)
+ output = &OutputService14TestShapeOutputShape{}
+ req.Data = output
+ return
+}
+
+func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (output *OutputService14TestShapeOutputShape, err error) {
+ req, out := c.OutputService14TestCaseOperation1Request(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opOutputService14TestCaseOperation1 *aws.Operation
+
+type OutputService14TestShapeOutputService14TestCaseOperation1Input struct {
+ metadataOutputService14TestShapeOutputService14TestCaseOperation1Input `json:"-" xml:"-"`
+}
+
+type metadataOutputService14TestShapeOutputService14TestCaseOperation1Input struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type OutputService14TestShapeOutputShape struct {
+ Map *map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
+
+ metadataOutputService14TestShapeOutputShape `json:"-" xml:"-"`
+}
+
+type metadataOutputService14TestShapeOutputShape struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+//
+// Tests begin here
+//
+
+func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
+ svc := NewOutputService1ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("myname123falsetrue1.21.3200a2015-01-25T08:00:00Zrequest-id"))
+ req, out := svc.OutputService1TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
+ assert.Equal(t, true, *out.TrueBool)
+
+}
+
+func TestOutputService2ProtocolTestNotAllMembersInResponseCase1(t *testing.T) {
+ svc := NewOutputService2ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("mynamerequest-id"))
+ req, out := svc.OutputService2TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.Unmarshal(req)
+ assert.NoError(t, req.Error)
+
+ // assert response
+ assert.NotNil(t, out) // ensure out variable is used
+ assert.Equal(t, "myname", *out.Str)
+
+}
+
+func TestOutputService3ProtocolTestBlobCase1(t *testing.T) {
+ svc := NewOutputService3ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("dmFsdWU=requestid"))
+ req, out := svc.OutputService3TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService4ProtocolTestListsCase1(t *testing.T) {
+ svc := NewOutputService4ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("abc123requestid"))
+ req, out := svc.OutputService4TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService5ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
+ svc := NewOutputService5ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("- abc
- 123
requestid"))
+ req, out := svc.OutputService5TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService6ProtocolTestFlattenedListCase1(t *testing.T) {
+ svc := NewOutputService6ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("abc123requestid"))
+ req, out := svc.OutputService6TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService7ProtocolTestFlattenedSingleElementListCase1(t *testing.T) {
+ svc := NewOutputService7ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("abcrequestid"))
+ req, out := svc.OutputService7TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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])
+
+}
+
+func TestOutputService8ProtocolTestListOfStructuresCase1(t *testing.T) {
+ svc := NewOutputService8ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("firstfoofirstbarfirstbazsecondfoosecondbarsecondbaz
requestid"))
+ req, out := svc.OutputService8TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.Unmarshal(req)
+ assert.NoError(t, req.Error)
+
+ // assert response
+ assert.NotNil(t, out) // ensure out variable is used
+ assert.Equal(t, "firstbar", *out.List[0].Bar)
+ assert.Equal(t, "firstbaz", *out.List[0].Baz)
+ assert.Equal(t, "firstfoo", *out.List[0].Foo)
+ assert.Equal(t, "secondbar", *out.List[1].Bar)
+ assert.Equal(t, "secondbaz", *out.List[1].Baz)
+ assert.Equal(t, "secondfoo", *out.List[1].Foo)
+
+}
+
+func TestOutputService9ProtocolTestFlattenedListOfStructuresCase1(t *testing.T) {
+ svc := NewOutputService9ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("firstfoofirstbarfirstbaz
secondfoosecondbarsecondbaz
requestid"))
+ req, out := svc.OutputService9TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.Unmarshal(req)
+ assert.NoError(t, req.Error)
+
+ // assert response
+ assert.NotNil(t, out) // ensure out variable is used
+ assert.Equal(t, "firstbar", *out.List[0].Bar)
+ assert.Equal(t, "firstbaz", *out.List[0].Baz)
+ assert.Equal(t, "firstfoo", *out.List[0].Foo)
+ assert.Equal(t, "secondbar", *out.List[1].Bar)
+ assert.Equal(t, "secondbaz", *out.List[1].Baz)
+ assert.Equal(t, "secondfoo", *out.List[1].Foo)
+
+}
+
+func TestOutputService10ProtocolTestFlattenedListWithLocationNameCase1(t *testing.T) {
+ svc := NewOutputService10ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("abrequestid"))
+ req, out := svc.OutputService10TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.Unmarshal(req)
+ assert.NoError(t, req.Error)
+
+ // assert response
+ assert.NotNil(t, out) // ensure out variable is used
+ assert.Equal(t, "a", *out.List[0])
+ assert.Equal(t, "b", *out.List[1])
+
+}
+
+func TestOutputService11ProtocolTestNormalMapCase1(t *testing.T) {
+ svc := NewOutputService11ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("requestid"))
+ req, out := svc.OutputService11TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService12ProtocolTestFlattenedMapCase1(t *testing.T) {
+ svc := NewOutputService12ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("requestid"))
+ req, out := svc.OutputService12TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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 TestOutputService13ProtocolTestFlattenedMapInShapeDefinitionCase1(t *testing.T) {
+ svc := NewOutputService13ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("quxbarrequestid"))
+ req, out := svc.OutputService13TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.Unmarshal(req)
+ assert.NoError(t, req.Error)
+
+ // assert response
+ assert.NotNil(t, out) // ensure out variable is used
+ assert.Equal(t, "bar", *(*out.Map)["qux"])
+
+}
+
+func TestOutputService14ProtocolTestNamedMapCase1(t *testing.T) {
+ svc := NewOutputService14ProtocolTest(nil)
+
+ buf := bytes.NewReader([]byte("requestid"))
+ req, out := svc.OutputService14TestCaseOperation1Request(nil)
+ req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
+
+ // set headers
+
+ // unmarshal response
+ query.UnmarshalMeta(req)
+ query.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"])
+
+}
+
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/api.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/api.go
new file mode 100644
index 00000000000..b8538c0be35
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/api.go
@@ -0,0 +1,2459 @@
+// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
+
+// Package elb provides a client for Elastic Load Balancing.
+package elb
+
+import (
+ "sync"
+ "time"
+
+ "github.com/awslabs/aws-sdk-go/aws"
+)
+
+var oprw sync.Mutex
+
+// AddTagsRequest generates a request for the AddTags operation.
+func (c *ELB) AddTagsRequest(input *AddTagsInput) (req *aws.Request, output *AddTagsOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opAddTags == nil {
+ opAddTags = &aws.Operation{
+ Name: "AddTags",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &AddTagsInput{}
+ }
+
+ req = c.newRequest(opAddTags, input, output)
+ output = &AddTagsOutput{}
+ req.Data = output
+ return
+}
+
+// Adds the specified tags to the specified load balancer. Each load balancer
+// can have a maximum of 10 tags.
+//
+// Each tag consists of a key and an optional value. If a tag with the same
+// key is already associated with the load balancer, AddTags updates its value.
+//
+// For more information, see Tagging (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#tagging-elb)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) AddTags(input *AddTagsInput) (output *AddTagsOutput, err error) {
+ req, out := c.AddTagsRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opAddTags *aws.Operation
+
+// ApplySecurityGroupsToLoadBalancerRequest generates a request for the ApplySecurityGroupsToLoadBalancer operation.
+func (c *ELB) ApplySecurityGroupsToLoadBalancerRequest(input *ApplySecurityGroupsToLoadBalancerInput) (req *aws.Request, output *ApplySecurityGroupsToLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opApplySecurityGroupsToLoadBalancer == nil {
+ opApplySecurityGroupsToLoadBalancer = &aws.Operation{
+ Name: "ApplySecurityGroupsToLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &ApplySecurityGroupsToLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opApplySecurityGroupsToLoadBalancer, input, output)
+ output = &ApplySecurityGroupsToLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Associates one or more security groups with your load balancer in a virtual
+// private cloud (VPC). The specified security groups override the previously
+// associated security groups.
+//
+// For more information, see Manage Security Groups for Amazon VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/USVPC_ApplySG.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) ApplySecurityGroupsToLoadBalancer(input *ApplySecurityGroupsToLoadBalancerInput) (output *ApplySecurityGroupsToLoadBalancerOutput, err error) {
+ req, out := c.ApplySecurityGroupsToLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opApplySecurityGroupsToLoadBalancer *aws.Operation
+
+// AttachLoadBalancerToSubnetsRequest generates a request for the AttachLoadBalancerToSubnets operation.
+func (c *ELB) AttachLoadBalancerToSubnetsRequest(input *AttachLoadBalancerToSubnetsInput) (req *aws.Request, output *AttachLoadBalancerToSubnetsOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opAttachLoadBalancerToSubnets == nil {
+ opAttachLoadBalancerToSubnets = &aws.Operation{
+ Name: "AttachLoadBalancerToSubnets",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &AttachLoadBalancerToSubnetsInput{}
+ }
+
+ req = c.newRequest(opAttachLoadBalancerToSubnets, input, output)
+ output = &AttachLoadBalancerToSubnetsOutput{}
+ req.Data = output
+ return
+}
+
+// Adds one or more subnets to the set of configured subnets for the specified
+// load balancer.
+//
+// The load balancer evenly distributes requests across all registered subnets.
+// For more information, see Elastic Load Balancing in Amazon VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForVPC.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) AttachLoadBalancerToSubnets(input *AttachLoadBalancerToSubnetsInput) (output *AttachLoadBalancerToSubnetsOutput, err error) {
+ req, out := c.AttachLoadBalancerToSubnetsRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opAttachLoadBalancerToSubnets *aws.Operation
+
+// ConfigureHealthCheckRequest generates a request for the ConfigureHealthCheck operation.
+func (c *ELB) ConfigureHealthCheckRequest(input *ConfigureHealthCheckInput) (req *aws.Request, output *ConfigureHealthCheckOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opConfigureHealthCheck == nil {
+ opConfigureHealthCheck = &aws.Operation{
+ Name: "ConfigureHealthCheck",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &ConfigureHealthCheckInput{}
+ }
+
+ req = c.newRequest(opConfigureHealthCheck, input, output)
+ output = &ConfigureHealthCheckOutput{}
+ req.Data = output
+ return
+}
+
+// Specifies the health check settings to use when evaluating the health state
+// of your back-end instances.
+//
+// For more information, see Health Checks (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#healthcheck)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) ConfigureHealthCheck(input *ConfigureHealthCheckInput) (output *ConfigureHealthCheckOutput, err error) {
+ req, out := c.ConfigureHealthCheckRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opConfigureHealthCheck *aws.Operation
+
+// CreateAppCookieStickinessPolicyRequest generates a request for the CreateAppCookieStickinessPolicy operation.
+func (c *ELB) CreateAppCookieStickinessPolicyRequest(input *CreateAppCookieStickinessPolicyInput) (req *aws.Request, output *CreateAppCookieStickinessPolicyOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opCreateAppCookieStickinessPolicy == nil {
+ opCreateAppCookieStickinessPolicy = &aws.Operation{
+ Name: "CreateAppCookieStickinessPolicy",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &CreateAppCookieStickinessPolicyInput{}
+ }
+
+ req = c.newRequest(opCreateAppCookieStickinessPolicy, input, output)
+ output = &CreateAppCookieStickinessPolicyOutput{}
+ req.Data = output
+ return
+}
+
+// Generates a stickiness policy with sticky session lifetimes that follow that
+// of an application-generated cookie. This policy can be associated only with
+// HTTP/HTTPS listeners.
+//
+// This policy is similar to the policy created by CreateLBCookieStickinessPolicy,
+// except that the lifetime of the special Elastic Load Balancing cookie, AWSELB,
+// follows the lifetime of the application-generated cookie specified in the
+// policy configuration. The load balancer only inserts a new stickiness cookie
+// when the application response includes a new application cookie.
+//
+// If the application cookie is explicitly removed or expires, the session
+// stops being sticky until a new application cookie is issued.
+//
+// For more information, see Application-Controlled Session Stickiness (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_StickySessions.html#US_EnableStickySessionsAppCookies)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) CreateAppCookieStickinessPolicy(input *CreateAppCookieStickinessPolicyInput) (output *CreateAppCookieStickinessPolicyOutput, err error) {
+ req, out := c.CreateAppCookieStickinessPolicyRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opCreateAppCookieStickinessPolicy *aws.Operation
+
+// CreateLBCookieStickinessPolicyRequest generates a request for the CreateLBCookieStickinessPolicy operation.
+func (c *ELB) CreateLBCookieStickinessPolicyRequest(input *CreateLBCookieStickinessPolicyInput) (req *aws.Request, output *CreateLBCookieStickinessPolicyOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opCreateLBCookieStickinessPolicy == nil {
+ opCreateLBCookieStickinessPolicy = &aws.Operation{
+ Name: "CreateLBCookieStickinessPolicy",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &CreateLBCookieStickinessPolicyInput{}
+ }
+
+ req = c.newRequest(opCreateLBCookieStickinessPolicy, input, output)
+ output = &CreateLBCookieStickinessPolicyOutput{}
+ req.Data = output
+ return
+}
+
+// Generates a stickiness policy with sticky session lifetimes controlled by
+// the lifetime of the browser (user-agent) or a specified expiration period.
+// This policy can be associated only with HTTP/HTTPS listeners.
+//
+// When a load balancer implements this policy, the load balancer uses a special
+// cookie to track the back-end server instance for each request. When the load
+// balancer receives a request, it first checks to see if this cookie is present
+// in the request. If so, the load balancer sends the request to the application
+// server specified in the cookie. If not, the load balancer sends the request
+// to a server that is chosen based on the existing load-balancing algorithm.
+//
+// A cookie is inserted into the response for binding subsequent requests from
+// the same user to that server. The validity of the cookie is based on the
+// cookie expiration time, which is specified in the policy configuration.
+//
+// For more information, see Duration-Based Session Stickiness (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_StickySessions.html#US_EnableStickySessionsLBCookies)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) CreateLBCookieStickinessPolicy(input *CreateLBCookieStickinessPolicyInput) (output *CreateLBCookieStickinessPolicyOutput, err error) {
+ req, out := c.CreateLBCookieStickinessPolicyRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opCreateLBCookieStickinessPolicy *aws.Operation
+
+// CreateLoadBalancerRequest generates a request for the CreateLoadBalancer operation.
+func (c *ELB) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *aws.Request, output *CreateLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opCreateLoadBalancer == nil {
+ opCreateLoadBalancer = &aws.Operation{
+ Name: "CreateLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &CreateLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opCreateLoadBalancer, input, output)
+ output = &CreateLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Creates a load balancer.
+//
+// If the call completes successfully, a new load balancer is created with
+// a unique Domain Name Service (DNS) name. The DNS name includes the name of
+// the AWS region in which the load balancer was created. For example, the DNS
+// name might end with either of the following:
+//
+// us-east-1.elb.amazonaws.com us-west-2.elb.amazonaws.com For information
+// about the AWS regions supported by Elastic Load Balancing, see Regions and
+// Endpoints (http://docs.aws.amazon.com/general/latest/gr/rande.html#elb_region)
+// in the Amazon Web Services General Reference.
+//
+// You can create up to 20 load balancers per region per account. You can request
+// an increase for the number of load balancers for your account. For more information,
+// see Elastic Load Balancing Limits (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-limits.html)
+// in the Elastic Load Balancing Developer Guide.
+//
+// Elastic Load Balancing supports load balancing your EC2 instances launched
+// in either the EC2-Classic or EC2-VPC platform. For more information, see
+// Elastic Load Balancing in EC2-Classic (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForEC2.html)
+// or Elastic Load Balancing in a VPC (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/UserScenariosForVPC.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) CreateLoadBalancer(input *CreateLoadBalancerInput) (output *CreateLoadBalancerOutput, err error) {
+ req, out := c.CreateLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opCreateLoadBalancer *aws.Operation
+
+// CreateLoadBalancerListenersRequest generates a request for the CreateLoadBalancerListeners operation.
+func (c *ELB) CreateLoadBalancerListenersRequest(input *CreateLoadBalancerListenersInput) (req *aws.Request, output *CreateLoadBalancerListenersOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opCreateLoadBalancerListeners == nil {
+ opCreateLoadBalancerListeners = &aws.Operation{
+ Name: "CreateLoadBalancerListeners",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &CreateLoadBalancerListenersInput{}
+ }
+
+ req = c.newRequest(opCreateLoadBalancerListeners, input, output)
+ output = &CreateLoadBalancerListenersOutput{}
+ req.Data = output
+ return
+}
+
+// Creates one or more listeners for the specified load balancer. If a listener
+// with the specified port does not already exist, it is created; otherwise,
+// the properties of the new listener must match the properties of the existing
+// listener.
+//
+// For more information, see Add a Listener to Your Load Balancer (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/us-add-listener.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) CreateLoadBalancerListeners(input *CreateLoadBalancerListenersInput) (output *CreateLoadBalancerListenersOutput, err error) {
+ req, out := c.CreateLoadBalancerListenersRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opCreateLoadBalancerListeners *aws.Operation
+
+// CreateLoadBalancerPolicyRequest generates a request for the CreateLoadBalancerPolicy operation.
+func (c *ELB) CreateLoadBalancerPolicyRequest(input *CreateLoadBalancerPolicyInput) (req *aws.Request, output *CreateLoadBalancerPolicyOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opCreateLoadBalancerPolicy == nil {
+ opCreateLoadBalancerPolicy = &aws.Operation{
+ Name: "CreateLoadBalancerPolicy",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &CreateLoadBalancerPolicyInput{}
+ }
+
+ req = c.newRequest(opCreateLoadBalancerPolicy, input, output)
+ output = &CreateLoadBalancerPolicyOutput{}
+ req.Data = output
+ return
+}
+
+// Creates a policy with the specified attributes for the specified load balancer.
+//
+// Policies are settings that are saved for your load balancer and that can
+// be applied to the front-end listener or the back-end application server,
+// depending on the policy type.
+func (c *ELB) CreateLoadBalancerPolicy(input *CreateLoadBalancerPolicyInput) (output *CreateLoadBalancerPolicyOutput, err error) {
+ req, out := c.CreateLoadBalancerPolicyRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opCreateLoadBalancerPolicy *aws.Operation
+
+// DeleteLoadBalancerRequest generates a request for the DeleteLoadBalancer operation.
+func (c *ELB) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *aws.Request, output *DeleteLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDeleteLoadBalancer == nil {
+ opDeleteLoadBalancer = &aws.Operation{
+ Name: "DeleteLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DeleteLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opDeleteLoadBalancer, input, output)
+ output = &DeleteLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Deletes the specified load balancer.
+//
+// If you are attempting to recreate a load balancer, you must reconfigure
+// all settings. The DNS name associated with a deleted load balancer are no
+// longer usable. The name and associated DNS record of the deleted load balancer
+// no longer exist and traffic sent to any of its IP addresses is no longer
+// delivered to back-end instances.
+//
+// If the load balancer does not exist or has already been deleted, the call
+// to DeleteLoadBalancer still succeeds.
+func (c *ELB) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (output *DeleteLoadBalancerOutput, err error) {
+ req, out := c.DeleteLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDeleteLoadBalancer *aws.Operation
+
+// DeleteLoadBalancerListenersRequest generates a request for the DeleteLoadBalancerListeners operation.
+func (c *ELB) DeleteLoadBalancerListenersRequest(input *DeleteLoadBalancerListenersInput) (req *aws.Request, output *DeleteLoadBalancerListenersOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDeleteLoadBalancerListeners == nil {
+ opDeleteLoadBalancerListeners = &aws.Operation{
+ Name: "DeleteLoadBalancerListeners",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DeleteLoadBalancerListenersInput{}
+ }
+
+ req = c.newRequest(opDeleteLoadBalancerListeners, input, output)
+ output = &DeleteLoadBalancerListenersOutput{}
+ req.Data = output
+ return
+}
+
+// Deletes the specified listeners from the specified load balancer.
+func (c *ELB) DeleteLoadBalancerListeners(input *DeleteLoadBalancerListenersInput) (output *DeleteLoadBalancerListenersOutput, err error) {
+ req, out := c.DeleteLoadBalancerListenersRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDeleteLoadBalancerListeners *aws.Operation
+
+// DeleteLoadBalancerPolicyRequest generates a request for the DeleteLoadBalancerPolicy operation.
+func (c *ELB) DeleteLoadBalancerPolicyRequest(input *DeleteLoadBalancerPolicyInput) (req *aws.Request, output *DeleteLoadBalancerPolicyOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDeleteLoadBalancerPolicy == nil {
+ opDeleteLoadBalancerPolicy = &aws.Operation{
+ Name: "DeleteLoadBalancerPolicy",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DeleteLoadBalancerPolicyInput{}
+ }
+
+ req = c.newRequest(opDeleteLoadBalancerPolicy, input, output)
+ output = &DeleteLoadBalancerPolicyOutput{}
+ req.Data = output
+ return
+}
+
+// Deletes the specified policy from the specified load balancer. This policy
+// must not be enabled for any listeners.
+func (c *ELB) DeleteLoadBalancerPolicy(input *DeleteLoadBalancerPolicyInput) (output *DeleteLoadBalancerPolicyOutput, err error) {
+ req, out := c.DeleteLoadBalancerPolicyRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDeleteLoadBalancerPolicy *aws.Operation
+
+// DeregisterInstancesFromLoadBalancerRequest generates a request for the DeregisterInstancesFromLoadBalancer operation.
+func (c *ELB) DeregisterInstancesFromLoadBalancerRequest(input *DeregisterInstancesFromLoadBalancerInput) (req *aws.Request, output *DeregisterInstancesFromLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDeregisterInstancesFromLoadBalancer == nil {
+ opDeregisterInstancesFromLoadBalancer = &aws.Operation{
+ Name: "DeregisterInstancesFromLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DeregisterInstancesFromLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opDeregisterInstancesFromLoadBalancer, input, output)
+ output = &DeregisterInstancesFromLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Deregisters the specified instances from the specified load balancer. After
+// the instance is deregistered, it no longer receives traffic from the load
+// balancer.
+//
+// You can use DescribeLoadBalancers to verify that the instance is deregistered
+// from the load balancer.
+//
+// For more information, see Deregister and Register Amazon EC2 Instances (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_DeReg_Reg_Instances.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) DeregisterInstancesFromLoadBalancer(input *DeregisterInstancesFromLoadBalancerInput) (output *DeregisterInstancesFromLoadBalancerOutput, err error) {
+ req, out := c.DeregisterInstancesFromLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDeregisterInstancesFromLoadBalancer *aws.Operation
+
+// DescribeInstanceHealthRequest generates a request for the DescribeInstanceHealth operation.
+func (c *ELB) DescribeInstanceHealthRequest(input *DescribeInstanceHealthInput) (req *aws.Request, output *DescribeInstanceHealthOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeInstanceHealth == nil {
+ opDescribeInstanceHealth = &aws.Operation{
+ Name: "DescribeInstanceHealth",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeInstanceHealthInput{}
+ }
+
+ req = c.newRequest(opDescribeInstanceHealth, input, output)
+ output = &DescribeInstanceHealthOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the state of the specified instances registered with the specified
+// load balancer. If no instances are specified, the call describes the state
+// of all instances registered with the load balancer, not including any terminated
+// instances.
+func (c *ELB) DescribeInstanceHealth(input *DescribeInstanceHealthInput) (output *DescribeInstanceHealthOutput, err error) {
+ req, out := c.DescribeInstanceHealthRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeInstanceHealth *aws.Operation
+
+// DescribeLoadBalancerAttributesRequest generates a request for the DescribeLoadBalancerAttributes operation.
+func (c *ELB) DescribeLoadBalancerAttributesRequest(input *DescribeLoadBalancerAttributesInput) (req *aws.Request, output *DescribeLoadBalancerAttributesOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeLoadBalancerAttributes == nil {
+ opDescribeLoadBalancerAttributes = &aws.Operation{
+ Name: "DescribeLoadBalancerAttributes",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeLoadBalancerAttributesInput{}
+ }
+
+ req = c.newRequest(opDescribeLoadBalancerAttributes, input, output)
+ output = &DescribeLoadBalancerAttributesOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the attributes for the specified load balancer.
+func (c *ELB) DescribeLoadBalancerAttributes(input *DescribeLoadBalancerAttributesInput) (output *DescribeLoadBalancerAttributesOutput, err error) {
+ req, out := c.DescribeLoadBalancerAttributesRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeLoadBalancerAttributes *aws.Operation
+
+// DescribeLoadBalancerPoliciesRequest generates a request for the DescribeLoadBalancerPolicies operation.
+func (c *ELB) DescribeLoadBalancerPoliciesRequest(input *DescribeLoadBalancerPoliciesInput) (req *aws.Request, output *DescribeLoadBalancerPoliciesOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeLoadBalancerPolicies == nil {
+ opDescribeLoadBalancerPolicies = &aws.Operation{
+ Name: "DescribeLoadBalancerPolicies",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeLoadBalancerPoliciesInput{}
+ }
+
+ req = c.newRequest(opDescribeLoadBalancerPolicies, input, output)
+ output = &DescribeLoadBalancerPoliciesOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the specified policies.
+//
+// If you specify a load balancer name, the action returns the descriptions
+// of all policies created for the load balancer. If you specify a policy name
+// associated with your load balancer, the action returns the description of
+// that policy. If you don't specify a load balancer name, the action returns
+// descriptions of the specified sample policies, or descriptions of all sample
+// policies. The names of the sample policies have the ELBSample- prefix.
+func (c *ELB) DescribeLoadBalancerPolicies(input *DescribeLoadBalancerPoliciesInput) (output *DescribeLoadBalancerPoliciesOutput, err error) {
+ req, out := c.DescribeLoadBalancerPoliciesRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeLoadBalancerPolicies *aws.Operation
+
+// DescribeLoadBalancerPolicyTypesRequest generates a request for the DescribeLoadBalancerPolicyTypes operation.
+func (c *ELB) DescribeLoadBalancerPolicyTypesRequest(input *DescribeLoadBalancerPolicyTypesInput) (req *aws.Request, output *DescribeLoadBalancerPolicyTypesOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeLoadBalancerPolicyTypes == nil {
+ opDescribeLoadBalancerPolicyTypes = &aws.Operation{
+ Name: "DescribeLoadBalancerPolicyTypes",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeLoadBalancerPolicyTypesInput{}
+ }
+
+ req = c.newRequest(opDescribeLoadBalancerPolicyTypes, input, output)
+ output = &DescribeLoadBalancerPolicyTypesOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the specified load balancer policy types.
+//
+// You can use these policy types with CreateLoadBalancerPolicy to create policy
+// configurations for a load balancer.
+func (c *ELB) DescribeLoadBalancerPolicyTypes(input *DescribeLoadBalancerPolicyTypesInput) (output *DescribeLoadBalancerPolicyTypesOutput, err error) {
+ req, out := c.DescribeLoadBalancerPolicyTypesRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeLoadBalancerPolicyTypes *aws.Operation
+
+// DescribeLoadBalancersRequest generates a request for the DescribeLoadBalancers operation.
+func (c *ELB) DescribeLoadBalancersRequest(input *DescribeLoadBalancersInput) (req *aws.Request, output *DescribeLoadBalancersOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeLoadBalancers == nil {
+ opDescribeLoadBalancers = &aws.Operation{
+ Name: "DescribeLoadBalancers",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeLoadBalancersInput{}
+ }
+
+ req = c.newRequest(opDescribeLoadBalancers, input, output)
+ output = &DescribeLoadBalancersOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the specified the load balancers. If no load balancers are specified,
+// the call describes all of your load balancers.
+func (c *ELB) DescribeLoadBalancers(input *DescribeLoadBalancersInput) (output *DescribeLoadBalancersOutput, err error) {
+ req, out := c.DescribeLoadBalancersRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeLoadBalancers *aws.Operation
+
+// DescribeTagsRequest generates a request for the DescribeTags operation.
+func (c *ELB) DescribeTagsRequest(input *DescribeTagsInput) (req *aws.Request, output *DescribeTagsOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDescribeTags == nil {
+ opDescribeTags = &aws.Operation{
+ Name: "DescribeTags",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DescribeTagsInput{}
+ }
+
+ req = c.newRequest(opDescribeTags, input, output)
+ output = &DescribeTagsOutput{}
+ req.Data = output
+ return
+}
+
+// Describes the tags associated with the specified load balancers.
+func (c *ELB) DescribeTags(input *DescribeTagsInput) (output *DescribeTagsOutput, err error) {
+ req, out := c.DescribeTagsRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDescribeTags *aws.Operation
+
+// DetachLoadBalancerFromSubnetsRequest generates a request for the DetachLoadBalancerFromSubnets operation.
+func (c *ELB) DetachLoadBalancerFromSubnetsRequest(input *DetachLoadBalancerFromSubnetsInput) (req *aws.Request, output *DetachLoadBalancerFromSubnetsOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDetachLoadBalancerFromSubnets == nil {
+ opDetachLoadBalancerFromSubnets = &aws.Operation{
+ Name: "DetachLoadBalancerFromSubnets",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DetachLoadBalancerFromSubnetsInput{}
+ }
+
+ req = c.newRequest(opDetachLoadBalancerFromSubnets, input, output)
+ output = &DetachLoadBalancerFromSubnetsOutput{}
+ req.Data = output
+ return
+}
+
+// Removes the specified subnets from the set of configured subnets for the
+// load balancer.
+//
+// After a subnet is removed, all EC2 instances registered with the load balancer
+// in the removed subnet go into the OutOfService state. Then, the load balancer
+// balances the traffic among the remaining routable subnets.
+func (c *ELB) DetachLoadBalancerFromSubnets(input *DetachLoadBalancerFromSubnetsInput) (output *DetachLoadBalancerFromSubnetsOutput, err error) {
+ req, out := c.DetachLoadBalancerFromSubnetsRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDetachLoadBalancerFromSubnets *aws.Operation
+
+// DisableAvailabilityZonesForLoadBalancerRequest generates a request for the DisableAvailabilityZonesForLoadBalancer operation.
+func (c *ELB) DisableAvailabilityZonesForLoadBalancerRequest(input *DisableAvailabilityZonesForLoadBalancerInput) (req *aws.Request, output *DisableAvailabilityZonesForLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opDisableAvailabilityZonesForLoadBalancer == nil {
+ opDisableAvailabilityZonesForLoadBalancer = &aws.Operation{
+ Name: "DisableAvailabilityZonesForLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &DisableAvailabilityZonesForLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opDisableAvailabilityZonesForLoadBalancer, input, output)
+ output = &DisableAvailabilityZonesForLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Removes the specified Availability Zones from the set of Availability Zones
+// for the specified load balancer.
+//
+// There must be at least one Availability Zone registered with a load balancer
+// at all times. After an Availability Zone is removed, all instances registered
+// with the load balancer that are in the removed Availability Zone go into
+// the OutOfService state. Then, the load balancer attempts to equally balance
+// the traffic among its remaining Availability Zones.
+//
+// For more information, see Disable an Availability Zone from a Load-Balanced
+// Application (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_ShrinkLBApp04.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) DisableAvailabilityZonesForLoadBalancer(input *DisableAvailabilityZonesForLoadBalancerInput) (output *DisableAvailabilityZonesForLoadBalancerOutput, err error) {
+ req, out := c.DisableAvailabilityZonesForLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opDisableAvailabilityZonesForLoadBalancer *aws.Operation
+
+// EnableAvailabilityZonesForLoadBalancerRequest generates a request for the EnableAvailabilityZonesForLoadBalancer operation.
+func (c *ELB) EnableAvailabilityZonesForLoadBalancerRequest(input *EnableAvailabilityZonesForLoadBalancerInput) (req *aws.Request, output *EnableAvailabilityZonesForLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opEnableAvailabilityZonesForLoadBalancer == nil {
+ opEnableAvailabilityZonesForLoadBalancer = &aws.Operation{
+ Name: "EnableAvailabilityZonesForLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &EnableAvailabilityZonesForLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opEnableAvailabilityZonesForLoadBalancer, input, output)
+ output = &EnableAvailabilityZonesForLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Adds the specified Availability Zones to the set of Availability Zones for
+// the specified load balancer.
+//
+// The load balancer evenly distributes requests across all its registered
+// Availability Zones that contain instances.
+//
+// For more information, see Add Availability Zone (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_AddLBAvailabilityZone.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) EnableAvailabilityZonesForLoadBalancer(input *EnableAvailabilityZonesForLoadBalancerInput) (output *EnableAvailabilityZonesForLoadBalancerOutput, err error) {
+ req, out := c.EnableAvailabilityZonesForLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opEnableAvailabilityZonesForLoadBalancer *aws.Operation
+
+// ModifyLoadBalancerAttributesRequest generates a request for the ModifyLoadBalancerAttributes operation.
+func (c *ELB) ModifyLoadBalancerAttributesRequest(input *ModifyLoadBalancerAttributesInput) (req *aws.Request, output *ModifyLoadBalancerAttributesOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opModifyLoadBalancerAttributes == nil {
+ opModifyLoadBalancerAttributes = &aws.Operation{
+ Name: "ModifyLoadBalancerAttributes",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &ModifyLoadBalancerAttributesInput{}
+ }
+
+ req = c.newRequest(opModifyLoadBalancerAttributes, input, output)
+ output = &ModifyLoadBalancerAttributesOutput{}
+ req.Data = output
+ return
+}
+
+// Modifies the attributes of the specified load balancer.
+//
+// You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining,
+// and CrossZoneLoadBalancing by either enabling or disabling them. Or, you
+// can modify the load balancer attribute ConnectionSettings by specifying an
+// idle connection timeout value for your load balancer.
+//
+// For more information, see the following in the Elastic Load Balancing Developer
+// Guide:
+//
+// Cross-Zone Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#request-routing)
+// Connection Draining (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#conn-drain)
+// Access Logs (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/access-log-collection.html)
+// Idle Connection Timeout (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#idle-timeout)
+func (c *ELB) ModifyLoadBalancerAttributes(input *ModifyLoadBalancerAttributesInput) (output *ModifyLoadBalancerAttributesOutput, err error) {
+ req, out := c.ModifyLoadBalancerAttributesRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opModifyLoadBalancerAttributes *aws.Operation
+
+// RegisterInstancesWithLoadBalancerRequest generates a request for the RegisterInstancesWithLoadBalancer operation.
+func (c *ELB) RegisterInstancesWithLoadBalancerRequest(input *RegisterInstancesWithLoadBalancerInput) (req *aws.Request, output *RegisterInstancesWithLoadBalancerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opRegisterInstancesWithLoadBalancer == nil {
+ opRegisterInstancesWithLoadBalancer = &aws.Operation{
+ Name: "RegisterInstancesWithLoadBalancer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &RegisterInstancesWithLoadBalancerInput{}
+ }
+
+ req = c.newRequest(opRegisterInstancesWithLoadBalancer, input, output)
+ output = &RegisterInstancesWithLoadBalancerOutput{}
+ req.Data = output
+ return
+}
+
+// Adds the specified instances to the specified load balancer.
+//
+// The instance must be a running instance in the same network as the load
+// balancer (EC2-Classic or the same VPC). If you have EC2-Classic instances
+// and a load balancer in a VPC with ClassicLink enabled, you can link the EC2-Classic
+// instances to that VPC and then register the linked EC2-Classic instances
+// with the load balancer in the VPC.
+//
+// Note that RegisterInstanceWithLoadBalancer completes when the request has
+// been registered. Instance registration happens shortly afterwards. To check
+// the state of the registered instances, use DescribeLoadBalancers or DescribeInstanceHealth.
+//
+// After the instance is registered, it starts receiving traffic and requests
+// from the load balancer. Any instance that is not in one of the Availability
+// Zones registered for the load balancer is moved to the OutOfService state.
+// If an Availability Zone is added to the load balancer later, any instances
+// registered with the load balancer move to the InService state.
+//
+// If you stop an instance registered with a load balancer and then start it,
+// the IP addresses associated with the instance changes. Elastic Load Balancing
+// cannot recognize the new IP address, which prevents it from routing traffic
+// to the instances. We recommend that you use the following sequence: stop
+// the instance, deregister the instance, start the instance, and then register
+// the instance. To deregister instances from a load balancer, use DeregisterInstancesFromLoadBalancer.
+//
+// For more information, see Deregister and Register EC2 Instances (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_DeReg_Reg_Instances.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) RegisterInstancesWithLoadBalancer(input *RegisterInstancesWithLoadBalancerInput) (output *RegisterInstancesWithLoadBalancerOutput, err error) {
+ req, out := c.RegisterInstancesWithLoadBalancerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opRegisterInstancesWithLoadBalancer *aws.Operation
+
+// RemoveTagsRequest generates a request for the RemoveTags operation.
+func (c *ELB) RemoveTagsRequest(input *RemoveTagsInput) (req *aws.Request, output *RemoveTagsOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opRemoveTags == nil {
+ opRemoveTags = &aws.Operation{
+ Name: "RemoveTags",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &RemoveTagsInput{}
+ }
+
+ req = c.newRequest(opRemoveTags, input, output)
+ output = &RemoveTagsOutput{}
+ req.Data = output
+ return
+}
+
+// Removes one or more tags from the specified load balancer.
+func (c *ELB) RemoveTags(input *RemoveTagsInput) (output *RemoveTagsOutput, err error) {
+ req, out := c.RemoveTagsRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opRemoveTags *aws.Operation
+
+// SetLoadBalancerListenerSSLCertificateRequest generates a request for the SetLoadBalancerListenerSSLCertificate operation.
+func (c *ELB) SetLoadBalancerListenerSSLCertificateRequest(input *SetLoadBalancerListenerSSLCertificateInput) (req *aws.Request, output *SetLoadBalancerListenerSSLCertificateOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opSetLoadBalancerListenerSSLCertificate == nil {
+ opSetLoadBalancerListenerSSLCertificate = &aws.Operation{
+ Name: "SetLoadBalancerListenerSSLCertificate",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &SetLoadBalancerListenerSSLCertificateInput{}
+ }
+
+ req = c.newRequest(opSetLoadBalancerListenerSSLCertificate, input, output)
+ output = &SetLoadBalancerListenerSSLCertificateOutput{}
+ req.Data = output
+ return
+}
+
+// Sets the certificate that terminates the specified listener's SSL connections.
+// The specified certificate replaces any prior certificate that was used on
+// the same load balancer and port.
+//
+// For more information about updating your SSL certificate, see Updating an
+// SSL Certificate for a Load Balancer (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/US_UpdatingLoadBalancerSSL.html)
+// in the Elastic Load Balancing Developer Guide.
+func (c *ELB) SetLoadBalancerListenerSSLCertificate(input *SetLoadBalancerListenerSSLCertificateInput) (output *SetLoadBalancerListenerSSLCertificateOutput, err error) {
+ req, out := c.SetLoadBalancerListenerSSLCertificateRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opSetLoadBalancerListenerSSLCertificate *aws.Operation
+
+// SetLoadBalancerPoliciesForBackendServerRequest generates a request for the SetLoadBalancerPoliciesForBackendServer operation.
+func (c *ELB) SetLoadBalancerPoliciesForBackendServerRequest(input *SetLoadBalancerPoliciesForBackendServerInput) (req *aws.Request, output *SetLoadBalancerPoliciesForBackendServerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opSetLoadBalancerPoliciesForBackendServer == nil {
+ opSetLoadBalancerPoliciesForBackendServer = &aws.Operation{
+ Name: "SetLoadBalancerPoliciesForBackendServer",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &SetLoadBalancerPoliciesForBackendServerInput{}
+ }
+
+ req = c.newRequest(opSetLoadBalancerPoliciesForBackendServer, input, output)
+ output = &SetLoadBalancerPoliciesForBackendServerOutput{}
+ req.Data = output
+ return
+}
+
+// Replaces the set of policies associated with the specified port on which
+// the back-end server is listening with a new set of policies. At this time,
+// only the back-end server authentication policy type can be applied to the
+// back-end ports; this policy type is composed of multiple public key policies.
+//
+// Each time you use SetLoadBalancerPoliciesForBackendServer to enable the
+// policies, use the PolicyNames parameter to list the policies that you want
+// to enable.
+//
+// You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to verify
+// that the policy is associated with the back-end server.
+func (c *ELB) SetLoadBalancerPoliciesForBackendServer(input *SetLoadBalancerPoliciesForBackendServerInput) (output *SetLoadBalancerPoliciesForBackendServerOutput, err error) {
+ req, out := c.SetLoadBalancerPoliciesForBackendServerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opSetLoadBalancerPoliciesForBackendServer *aws.Operation
+
+// SetLoadBalancerPoliciesOfListenerRequest generates a request for the SetLoadBalancerPoliciesOfListener operation.
+func (c *ELB) SetLoadBalancerPoliciesOfListenerRequest(input *SetLoadBalancerPoliciesOfListenerInput) (req *aws.Request, output *SetLoadBalancerPoliciesOfListenerOutput) {
+ oprw.Lock()
+ defer oprw.Unlock()
+
+ if opSetLoadBalancerPoliciesOfListener == nil {
+ opSetLoadBalancerPoliciesOfListener = &aws.Operation{
+ Name: "SetLoadBalancerPoliciesOfListener",
+ HTTPMethod: "POST",
+ HTTPPath: "/",
+ }
+ }
+
+ if input == nil {
+ input = &SetLoadBalancerPoliciesOfListenerInput{}
+ }
+
+ req = c.newRequest(opSetLoadBalancerPoliciesOfListener, input, output)
+ output = &SetLoadBalancerPoliciesOfListenerOutput{}
+ req.Data = output
+ return
+}
+
+// Associates, updates, or disables a policy with a listener for the specified
+// load balancer. You can associate multiple policies with a listener.
+func (c *ELB) SetLoadBalancerPoliciesOfListener(input *SetLoadBalancerPoliciesOfListenerInput) (output *SetLoadBalancerPoliciesOfListenerOutput, err error) {
+ req, out := c.SetLoadBalancerPoliciesOfListenerRequest(input)
+ output = out
+ err = req.Send()
+ return
+}
+
+var opSetLoadBalancerPoliciesOfListener *aws.Operation
+
+// Information about the AccessLog attribute.
+type AccessLog struct {
+ // The interval for publishing the access logs. You can specify an interval
+ // of either 5 minutes or 60 minutes.
+ //
+ // Default: 60 minutes
+ EmitInterval *int64 `type:"integer"`
+
+ // Specifies whether access log is enabled for the load balancer.
+ Enabled *bool `type:"boolean" required:"true"`
+
+ // The name of the Amazon S3 bucket where the access logs are stored.
+ S3BucketName *string `type:"string"`
+
+ // The logical hierarchy you created for your Amazon S3 bucket, for example
+ // my-bucket-prefix/prod. If the prefix is not provided, the log is placed at
+ // the root level of the bucket.
+ S3BucketPrefix *string `type:"string"`
+
+ metadataAccessLog `json:"-" xml:"-"`
+}
+
+type metadataAccessLog struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type AddTagsInput struct {
+ // The name of the load balancer. You can specify one load balancer only.
+ LoadBalancerNames []*string `type:"list" required:"true"`
+
+ // The tags.
+ Tags []*Tag `type:"list" required:"true"`
+
+ metadataAddTagsInput `json:"-" xml:"-"`
+}
+
+type metadataAddTagsInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type AddTagsOutput struct {
+ metadataAddTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataAddTagsOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// This data type is reserved.
+type AdditionalAttribute struct {
+ // This parameter is reserved.
+ Key *string `type:"string"`
+
+ // This parameter is reserved.
+ Value *string `type:"string"`
+
+ metadataAdditionalAttribute `json:"-" xml:"-"`
+}
+
+type metadataAdditionalAttribute struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy for application-controlled session stickiness.
+type AppCookieStickinessPolicy struct {
+ // The name of the application cookie used for stickiness.
+ CookieName *string `type:"string"`
+
+ // The mnemonic name for the policy being created. The name must be unique within
+ // a set of policies for this load balancer.
+ PolicyName *string `type:"string"`
+
+ metadataAppCookieStickinessPolicy `json:"-" xml:"-"`
+}
+
+type metadataAppCookieStickinessPolicy struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ApplySecurityGroupsToLoadBalancerInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The IDs of the security groups to associate with the load balancer. Note
+ // that you cannot specify the name of the security group.
+ SecurityGroups []*string `type:"list" required:"true"`
+
+ metadataApplySecurityGroupsToLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataApplySecurityGroupsToLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ApplySecurityGroupsToLoadBalancerOutput struct {
+ // The IDs of the security groups associated with the load balancer.
+ SecurityGroups []*string `type:"list"`
+
+ metadataApplySecurityGroupsToLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataApplySecurityGroupsToLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type AttachLoadBalancerToSubnetsInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The IDs of the subnets to add for the load balancer. You can add only one
+ // subnet per Availability Zone.
+ Subnets []*string `type:"list" required:"true"`
+
+ metadataAttachLoadBalancerToSubnetsInput `json:"-" xml:"-"`
+}
+
+type metadataAttachLoadBalancerToSubnetsInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type AttachLoadBalancerToSubnetsOutput struct {
+ // The IDs of the subnets attached to the load balancer.
+ Subnets []*string `type:"list"`
+
+ metadataAttachLoadBalancerToSubnetsOutput `json:"-" xml:"-"`
+}
+
+type metadataAttachLoadBalancerToSubnetsOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about the configuration of a back-end server.
+type BackendServerDescription struct {
+ // The port on which the back-end server is listening.
+ InstancePort *int64 `type:"integer"`
+
+ // The names of the policies enabled for the back-end server.
+ PolicyNames []*string `type:"list"`
+
+ metadataBackendServerDescription `json:"-" xml:"-"`
+}
+
+type metadataBackendServerDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ConfigureHealthCheckInput struct {
+ // The configuration information for the new health check.
+ HealthCheck *HealthCheck `type:"structure" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataConfigureHealthCheckInput `json:"-" xml:"-"`
+}
+
+type metadataConfigureHealthCheckInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ConfigureHealthCheckOutput struct {
+ // The updated health check.
+ HealthCheck *HealthCheck `type:"structure"`
+
+ metadataConfigureHealthCheckOutput `json:"-" xml:"-"`
+}
+
+type metadataConfigureHealthCheckOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about the ConnectionDraining attribute.
+type ConnectionDraining struct {
+ // Specifies whether connection draining is enabled for the load balancer.
+ Enabled *bool `type:"boolean" required:"true"`
+
+ // The maximum time, in seconds, to keep the existing connections open before
+ // deregistering the instances.
+ Timeout *int64 `type:"integer"`
+
+ metadataConnectionDraining `json:"-" xml:"-"`
+}
+
+type metadataConnectionDraining struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about the ConnectionSettings attribute.
+type ConnectionSettings struct {
+ // The time, in seconds, that the connection is allowed to be idle (no data
+ // has been sent over the connection) before it is closed by the load balancer.
+ IdleTimeout *int64 `type:"integer" required:"true"`
+
+ metadataConnectionSettings `json:"-" xml:"-"`
+}
+
+type metadataConnectionSettings struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateAppCookieStickinessPolicyInput struct {
+ // The name of the application cookie used for stickiness.
+ CookieName *string `type:"string" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The name of the policy being created. This name must be unique within the
+ // set of policies for this load balancer.
+ PolicyName *string `type:"string" required:"true"`
+
+ metadataCreateAppCookieStickinessPolicyInput `json:"-" xml:"-"`
+}
+
+type metadataCreateAppCookieStickinessPolicyInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateAppCookieStickinessPolicyOutput struct {
+ metadataCreateAppCookieStickinessPolicyOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateAppCookieStickinessPolicyOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLBCookieStickinessPolicyInput struct {
+ // The time period, in seconds, after which the cookie should be considered
+ // stale. If you do not specify this parameter, the sticky session lasts for
+ // the duration of the browser session.
+ CookieExpirationPeriod *int64 `type:"long"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The name of the policy being created. This name must be unique within the
+ // set of policies for this load balancer.
+ PolicyName *string `type:"string" required:"true"`
+
+ metadataCreateLBCookieStickinessPolicyInput `json:"-" xml:"-"`
+}
+
+type metadataCreateLBCookieStickinessPolicyInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLBCookieStickinessPolicyOutput struct {
+ metadataCreateLBCookieStickinessPolicyOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateLBCookieStickinessPolicyOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerInput struct {
+ // One or more Availability Zones from the same region as the load balancer.
+ // Traffic is equally distributed across all specified Availability Zones.
+ //
+ // You must specify at least one Availability Zone.
+ //
+ // You can add more Availability Zones after you create the load balancer using
+ // EnableAvailabilityZonesForLoadBalancer.
+ AvailabilityZones []*string `type:"list"`
+
+ // The listeners.
+ //
+ // For more information, see Listener Configurations for Elastic Load Balancing
+ // (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-listener-config.html)
+ // in the Elastic Load Balancing Developer Guide.
+ Listeners []*Listener `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ //
+ // This name must be unique within your AWS account, must have a maximum of
+ // 32 characters, must contain only alphanumeric characters or hyphens, and
+ // cannot begin or end with a hyphen.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The type of a load balancer. Valid only for load balancers in a VPC.
+ //
+ // By default, Elastic Load Balancing creates an Internet-facing load balancer
+ // with a publicly resolvable DNS name, which resolves to public IP addresses.
+ // For more information about Internet-facing and Internal load balancers, see
+ // Internet-facing and Internal Load Balancers (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/vpc-loadbalancer-types.html)
+ // in the Elastic Load Balancing Developer Guide.
+ //
+ // Specify internal to create an internal load balancer with a DNS name that
+ // resolves to private IP addresses.
+ Scheme *string `type:"string"`
+
+ // The IDs of the security groups to assign to the load balancer.
+ SecurityGroups []*string `type:"list"`
+
+ // The IDs of the subnets in your VPC to attach to the load balancer. Specify
+ // one subnet per Availability Zone specified in AvailabilityZones.
+ Subnets []*string `type:"list"`
+
+ // A list of tags to assign to the load balancer.
+ //
+ // For more information about tagging your load balancer, see Tagging (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/TerminologyandKeyConcepts.html#tagging-elb)
+ // in the Elastic Load Balancing Developer Guide.
+ Tags []*Tag `type:"list"`
+
+ metadataCreateLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerListenersInput struct {
+ // The listeners.
+ Listeners []*Listener `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataCreateLoadBalancerListenersInput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerListenersInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerListenersOutput struct {
+ metadataCreateLoadBalancerListenersOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerListenersOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerOutput struct {
+ // The DNS name of the load balancer.
+ DNSName *string `type:"string"`
+
+ metadataCreateLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerPolicyInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The attributes for the policy.
+ PolicyAttributes []*PolicyAttribute `type:"list"`
+
+ // The name of the load balancer policy to be created. This name must be unique
+ // within the set of policies for this load balancer.
+ PolicyName *string `type:"string" required:"true"`
+
+ // The name of the base policy type. To get the list of policy types, use DescribeLoadBalancerPolicyTypes.
+ PolicyTypeName *string `type:"string" required:"true"`
+
+ metadataCreateLoadBalancerPolicyInput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerPolicyInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type CreateLoadBalancerPolicyOutput struct {
+ metadataCreateLoadBalancerPolicyOutput `json:"-" xml:"-"`
+}
+
+type metadataCreateLoadBalancerPolicyOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about the CrossZoneLoadBalancing attribute.
+type CrossZoneLoadBalancing struct {
+ // Specifies whether cross-zone load balancing is enabled for the load balancer.
+ Enabled *bool `type:"boolean" required:"true"`
+
+ metadataCrossZoneLoadBalancing `json:"-" xml:"-"`
+}
+
+type metadataCrossZoneLoadBalancing struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeleteLoadBalancerInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataDeleteLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeleteLoadBalancerListenersInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The client port numbers of the listeners.
+ LoadBalancerPorts []*int64 `type:"list" required:"true"`
+
+ metadataDeleteLoadBalancerListenersInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerListenersInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeleteLoadBalancerListenersOutput struct {
+ metadataDeleteLoadBalancerListenersOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerListenersOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeleteLoadBalancerOutput struct {
+ metadataDeleteLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// =
+type DeleteLoadBalancerPolicyInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The name of the policy.
+ PolicyName *string `type:"string" required:"true"`
+
+ metadataDeleteLoadBalancerPolicyInput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerPolicyInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeleteLoadBalancerPolicyOutput struct {
+ metadataDeleteLoadBalancerPolicyOutput `json:"-" xml:"-"`
+}
+
+type metadataDeleteLoadBalancerPolicyOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeregisterInstancesFromLoadBalancerInput struct {
+ // The IDs of the instances.
+ Instances []*Instance `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataDeregisterInstancesFromLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataDeregisterInstancesFromLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DeregisterInstancesFromLoadBalancerOutput struct {
+ // The remaining instances registered with the load balancer.
+ Instances []*Instance `type:"list"`
+
+ metadataDeregisterInstancesFromLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataDeregisterInstancesFromLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeInstanceHealthInput struct {
+ // The IDs of the instances.
+ Instances []*Instance `type:"list"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataDescribeInstanceHealthInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceHealthInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeInstanceHealthOutput struct {
+ // Information about the health of the instances.
+ InstanceStates []*InstanceState `type:"list"`
+
+ metadataDescribeInstanceHealthOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeInstanceHealthOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerAttributesInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataDescribeLoadBalancerAttributesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerAttributesInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerAttributesOutput struct {
+ // Information about the load balancer attributes.
+ LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"`
+
+ metadataDescribeLoadBalancerAttributesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerAttributesOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerPoliciesInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string"`
+
+ // The names of the policies.
+ PolicyNames []*string `type:"list"`
+
+ metadataDescribeLoadBalancerPoliciesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerPoliciesInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerPoliciesOutput struct {
+ // Information about the policies.
+ PolicyDescriptions []*PolicyDescription `type:"list"`
+
+ metadataDescribeLoadBalancerPoliciesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerPoliciesOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerPolicyTypesInput struct {
+ // The names of the policy types. If no names are specified, describes all policy
+ // types defined by Elastic Load Balancing.
+ PolicyTypeNames []*string `type:"list"`
+
+ metadataDescribeLoadBalancerPolicyTypesInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerPolicyTypesInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancerPolicyTypesOutput struct {
+ // Information about the policy types.
+ PolicyTypeDescriptions []*PolicyTypeDescription `type:"list"`
+
+ metadataDescribeLoadBalancerPolicyTypesOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancerPolicyTypesOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancersInput struct {
+ // The names of the load balancers.
+ LoadBalancerNames []*string `type:"list"`
+
+ // The marker for the next set of results. (You received this marker from a
+ // previous call.)
+ Marker *string `type:"string"`
+
+ // The maximum number of results to return with this call (a number from 1 to
+ // 400). The default is 400.
+ PageSize *int64 `type:"integer"`
+
+ metadataDescribeLoadBalancersInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancersInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeLoadBalancersOutput struct {
+ // Information about the load balancers.
+ LoadBalancerDescriptions []*LoadBalancerDescription `type:"list"`
+
+ // The marker to use when requesting the next set of results. If there are no
+ // additional results, the string is empty.
+ NextMarker *string `type:"string"`
+
+ metadataDescribeLoadBalancersOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeLoadBalancersOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeTagsInput struct {
+ // The names of the load balancers.
+ LoadBalancerNames []*string `type:"list" required:"true"`
+
+ metadataDescribeTagsInput `json:"-" xml:"-"`
+}
+
+type metadataDescribeTagsInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DescribeTagsOutput struct {
+ // Information about the tags.
+ TagDescriptions []*TagDescription `type:"list"`
+
+ metadataDescribeTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataDescribeTagsOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DetachLoadBalancerFromSubnetsInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The IDs of the subnets.
+ Subnets []*string `type:"list" required:"true"`
+
+ metadataDetachLoadBalancerFromSubnetsInput `json:"-" xml:"-"`
+}
+
+type metadataDetachLoadBalancerFromSubnetsInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DetachLoadBalancerFromSubnetsOutput struct {
+ // The IDs of the remaining subnets for the load balancer.
+ Subnets []*string `type:"list"`
+
+ metadataDetachLoadBalancerFromSubnetsOutput `json:"-" xml:"-"`
+}
+
+type metadataDetachLoadBalancerFromSubnetsOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DisableAvailabilityZonesForLoadBalancerInput struct {
+ // The Availability Zones.
+ AvailabilityZones []*string `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataDisableAvailabilityZonesForLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataDisableAvailabilityZonesForLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type DisableAvailabilityZonesForLoadBalancerOutput struct {
+ // The remaining Availability Zones for the load balancer.
+ AvailabilityZones []*string `type:"list"`
+
+ metadataDisableAvailabilityZonesForLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataDisableAvailabilityZonesForLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type EnableAvailabilityZonesForLoadBalancerInput struct {
+ // The Availability Zones. These must be in the same region as the load balancer.
+ AvailabilityZones []*string `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataEnableAvailabilityZonesForLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataEnableAvailabilityZonesForLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type EnableAvailabilityZonesForLoadBalancerOutput struct {
+ // The updated list of Availability Zones for the load balancer.
+ AvailabilityZones []*string `type:"list"`
+
+ metadataEnableAvailabilityZonesForLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataEnableAvailabilityZonesForLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a health check.
+type HealthCheck struct {
+ // The number of consecutive health checks successes required before moving
+ // the instance to the Healthy state.
+ HealthyThreshold *int64 `type:"integer" required:"true"`
+
+ // The approximate interval, in seconds, between health checks of an individual
+ // instance.
+ Interval *int64 `type:"integer" required:"true"`
+
+ // The instance being checked. The protocol is either TCP, HTTP, HTTPS, or SSL.
+ // The range of valid ports is one (1) through 65535.
+ //
+ // TCP is the default, specified as a TCP: port pair, for example "TCP:5000".
+ // In this case, a health check simply attempts to open a TCP connection to
+ // the instance on the specified port. Failure to connect within the configured
+ // timeout is considered unhealthy.
+ //
+ // SSL is also specified as SSL: port pair, for example, SSL:5000.
+ //
+ // For HTTP/HTTPS, you must include a ping path in the string. HTTP is specified
+ // as a HTTP:port;/;PathToPing; grouping, for example "HTTP:80/weather/us/wa/seattle".
+ // In this case, a HTTP GET request is issued to the instance on the given port
+ // and path. Any answer other than "200 OK" within the timeout period is considered
+ // unhealthy.
+ //
+ // The total length of the HTTP ping target must be 1024 16-bit Unicode characters
+ // or less.
+ Target *string `type:"string" required:"true"`
+
+ // The amount of time, in seconds, during which no response means a failed health
+ // check.
+ //
+ // This value must be less than the Interval value.
+ Timeout *int64 `type:"integer" required:"true"`
+
+ // The number of consecutive health check failures required before moving the
+ // instance to the Unhealthy state.
+ UnhealthyThreshold *int64 `type:"integer" required:"true"`
+
+ metadataHealthCheck `json:"-" xml:"-"`
+}
+
+type metadataHealthCheck struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The ID of a back-end instance.
+type Instance struct {
+ // The ID of the instance.
+ InstanceID *string `locationName:"InstanceId" type:"string"`
+
+ metadataInstance `json:"-" xml:"-"`
+}
+
+type metadataInstance struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about the state of a back-end instance.
+type InstanceState struct {
+ // A description of the instance state. This string can contain one or more
+ // of the following messages.
+ //
+ // N/A
+ //
+ // A transient error occurred. Please try again later.
+ //
+ // Instance has failed at least the UnhealthyThreshold number of health checks
+ // consecutively.
+ //
+ // Instance has not passed the configured HealthyThreshold number of health
+ // checks consecutively.
+ //
+ // Instance registration is still in progress.
+ //
+ // Instance is in the EC2 Availability Zone for which LoadBalancer is not
+ // configured to route traffic to.
+ //
+ // Instance is not currently registered with the LoadBalancer.
+ //
+ // Instance deregistration currently in progress.
+ //
+ // Disable Availability Zone is currently in progress.
+ //
+ // Instance is in pending state.
+ //
+ // Instance is in stopped state.
+ //
+ // Instance is in terminated state.
+ Description *string `type:"string"`
+
+ // The ID of the instance.
+ InstanceID *string `locationName:"InstanceId" type:"string"`
+
+ // Information about the cause of OutOfService instances. Specifically, whether
+ // the cause is Elastic Load Balancing or the instance.
+ //
+ // Valid values: ELB | Instance | N/A
+ ReasonCode *string `type:"string"`
+
+ // The current state of the instance.
+ //
+ // Valid values: InService | OutOfService | Unknown
+ State *string `type:"string"`
+
+ metadataInstanceState `json:"-" xml:"-"`
+}
+
+type metadataInstanceState struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy for duration-based session stickiness.
+type LBCookieStickinessPolicy struct {
+ // The time period, in seconds, after which the cookie should be considered
+ // stale. If this parameter is not specified, the stickiness session lasts for
+ // the duration of the browser session.
+ CookieExpirationPeriod *int64 `type:"long"`
+
+ // The name for the policy being created. The name must be unique within the
+ // set of policies for this load balancer.
+ PolicyName *string `type:"string"`
+
+ metadataLBCookieStickinessPolicy `json:"-" xml:"-"`
+}
+
+type metadataLBCookieStickinessPolicy struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a listener.
+//
+// For information about the protocols and the ports supported by Elastic Load
+// Balancing, see Listener Configurations for Elastic Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-listener-config.html)
+// in the Elastic Load Balancing Developer Guide.
+type Listener struct {
+ // The port on which the instance server is listening - 25, 80, 443, 465, 587,
+ // or 1024-65535.
+ InstancePort *int64 `type:"integer" required:"true"`
+
+ // The protocol to use for routing traffic to back-end instances: HTTP, HTTPS,
+ // TCP, or SSL.
+ //
+ // If the front-end protocol is HTTP, HTTPS, TCP, or SSL, InstanceProtocol
+ // must be at the same protocol.
+ //
+ // If there is another listener with the same InstancePort whose InstanceProtocol
+ // is secure, (HTTPS or SSL), the listener's InstanceProtocol must also be secure.
+ //
+ // If there is another listener with the same InstancePort whose InstanceProtocol
+ // is HTTP or TCP, the listener's InstanceProtocol must be HTTP or TCP.
+ InstanceProtocol *string `type:"string"`
+
+ // The port on which the load balancer is listening: 25, 80, 443, 465, 587,
+ // or 1024-65535.
+ LoadBalancerPort *int64 `type:"integer" required:"true"`
+
+ // The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP,
+ // or SSL.
+ Protocol *string `type:"string" required:"true"`
+
+ // The Amazon Resource Name (ARN) of the server certificate.
+ SSLCertificateID *string `locationName:"SSLCertificateId" type:"string"`
+
+ metadataListener `json:"-" xml:"-"`
+}
+
+type metadataListener struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The policies enabled for a listener.
+type ListenerDescription struct {
+ // Information about a listener.
+ //
+ // For information about the protocols and the ports supported by Elastic Load
+ // Balancing, see Listener Configurations for Elastic Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-listener-config.html)
+ // in the Elastic Load Balancing Developer Guide.
+ Listener *Listener `type:"structure"`
+
+ // The policies. If there are no policies enabled, the list is empty.
+ PolicyNames []*string `type:"list"`
+
+ metadataListenerDescription `json:"-" xml:"-"`
+}
+
+type metadataListenerDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The attributes for a load balancer.
+type LoadBalancerAttributes struct {
+ // If enabled, the load balancer captures detailed information of all requests
+ // and delivers the information to the Amazon S3 bucket that you specify.
+ //
+ // For more information, see Enable Access Logs (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-access-logs.html)
+ // in the Elastic Load Balancing Developer Guide.
+ AccessLog *AccessLog `type:"structure"`
+
+ // This parameter is reserved.
+ AdditionalAttributes []*AdditionalAttribute `type:"list"`
+
+ // If enabled, the load balancer allows existing requests to complete before
+ // the load balancer shifts traffic away from a deregistered or unhealthy back-end
+ // instance.
+ //
+ // For more information, see Enable Connection Draining (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/config-conn-drain.html)
+ // in the Elastic Load Balancing Developer Guide.
+ ConnectionDraining *ConnectionDraining `type:"structure"`
+
+ // If enabled, the load balancer allows the connections to remain idle (no data
+ // is sent over the connection) for the specified duration.
+ //
+ // By default, Elastic Load Balancing maintains a 60-second idle connection
+ // timeout for both front-end and back-end connections of your load balancer.
+ // For more information, see Configure Idle Connection Timeout (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/config-idle-timeout.html)
+ // in the Elastic Load Balancing Developer Guide.
+ ConnectionSettings *ConnectionSettings `type:"structure"`
+
+ // If enabled, the load balancer routes the request traffic evenly across all
+ // back-end instances regardless of the Availability Zones.
+ //
+ // For more information, see Enable Cross-Zone Load Balancing (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-disable-crosszone-lb.html)
+ // in the Elastic Load Balancing Developer Guide.
+ CrossZoneLoadBalancing *CrossZoneLoadBalancing `type:"structure"`
+
+ metadataLoadBalancerAttributes `json:"-" xml:"-"`
+}
+
+type metadataLoadBalancerAttributes struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a load balancer.
+type LoadBalancerDescription struct {
+ // The Availability Zones for the load balancer.
+ AvailabilityZones []*string `type:"list"`
+
+ // Information about the back-end servers.
+ BackendServerDescriptions []*BackendServerDescription `type:"list"`
+
+ // The Amazon Route 53 hosted zone associated with the load balancer.
+ //
+ // For more information, see Using Domain Names With Elastic Load Balancing
+ // (http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/using-domain-names-with-elb.html)
+ // in the Elastic Load Balancing Developer Guide.
+ CanonicalHostedZoneName *string `type:"string"`
+
+ // The ID of the Amazon Route 53 hosted zone name associated with the load balancer.
+ CanonicalHostedZoneNameID *string `type:"string"`
+
+ // The date and time the load balancer was created.
+ CreatedTime *time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+ // The external DNS name of the load balancer.
+ DNSName *string `type:"string"`
+
+ // Information about the health checks conducted on the load balancer.
+ HealthCheck *HealthCheck `type:"structure"`
+
+ // The IDs of the instances for the load balancer.
+ Instances []*Instance `type:"list"`
+
+ // The listeners for the load balancer.
+ ListenerDescriptions []*ListenerDescription `type:"list"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string"`
+
+ // The policies defined for the load balancer.
+ Policies *Policies `type:"structure"`
+
+ // The type of load balancer. Valid only for load balancers in a VPC.
+ //
+ // If Scheme is internet-facing, the load balancer has a public DNS name that
+ // resolves to a public IP address.
+ //
+ // If Scheme is internal, the load balancer has a public DNS name that resolves
+ // to a private IP address.
+ Scheme *string `type:"string"`
+
+ // The security groups for the load balancer. Valid only for load balancers
+ // in a VPC.
+ SecurityGroups []*string `type:"list"`
+
+ // The security group that you can use as part of your inbound rules for your
+ // load balancer's back-end application instances. To only allow traffic from
+ // load balancers, add a security group rule to your back end instance that
+ // specifies this source security group as the inbound source.
+ SourceSecurityGroup *SourceSecurityGroup `type:"structure"`
+
+ // The IDs of the subnets for the load balancer.
+ Subnets []*string `type:"list"`
+
+ // The ID of the VPC for the load balancer.
+ VPCID *string `locationName:"VPCId" type:"string"`
+
+ metadataLoadBalancerDescription `json:"-" xml:"-"`
+}
+
+type metadataLoadBalancerDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ModifyLoadBalancerAttributesInput struct {
+ // The attributes of the load balancer.
+ LoadBalancerAttributes *LoadBalancerAttributes `type:"structure" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataModifyLoadBalancerAttributesInput `json:"-" xml:"-"`
+}
+
+type metadataModifyLoadBalancerAttributesInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type ModifyLoadBalancerAttributesOutput struct {
+ // The attributes for a load balancer.
+ LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string"`
+
+ metadataModifyLoadBalancerAttributesOutput `json:"-" xml:"-"`
+}
+
+type metadataModifyLoadBalancerAttributesOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The policies for a load balancer.
+type Policies struct {
+ // The stickiness policies created using CreateAppCookieStickinessPolicy.
+ AppCookieStickinessPolicies []*AppCookieStickinessPolicy `type:"list"`
+
+ // The stickiness policies created using CreateLBCookieStickinessPolicy.
+ LBCookieStickinessPolicies []*LBCookieStickinessPolicy `type:"list"`
+
+ // The policies other than the stickiness policies.
+ OtherPolicies []*string `type:"list"`
+
+ metadataPolicies `json:"-" xml:"-"`
+}
+
+type metadataPolicies struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy attribute.
+type PolicyAttribute struct {
+ // The name of the attribute.
+ AttributeName *string `type:"string"`
+
+ // The value of the attribute.
+ AttributeValue *string `type:"string"`
+
+ metadataPolicyAttribute `json:"-" xml:"-"`
+}
+
+type metadataPolicyAttribute struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy attribute.
+type PolicyAttributeDescription struct {
+ // The name of the attribute.
+ AttributeName *string `type:"string"`
+
+ // The value of the attribute.
+ AttributeValue *string `type:"string"`
+
+ metadataPolicyAttributeDescription `json:"-" xml:"-"`
+}
+
+type metadataPolicyAttributeDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy attribute type.
+type PolicyAttributeTypeDescription struct {
+ // The name of the attribute.
+ AttributeName *string `type:"string"`
+
+ // The type of the attribute. For example, Boolean or Integer.
+ AttributeType *string `type:"string"`
+
+ // The cardinality of the attribute.
+ //
+ // Valid values:
+ //
+ // ONE(1) : Single value required ZERO_OR_ONE(0..1) : Up to one value can
+ // be supplied ZERO_OR_MORE(0..*) : Optional. Multiple values are allowed ONE_OR_MORE(1..*0)
+ // : Required. Multiple values are allowed
+ Cardinality *string `type:"string"`
+
+ // The default value of the attribute, if applicable.
+ DefaultValue *string `type:"string"`
+
+ // A description of the attribute.
+ Description *string `type:"string"`
+
+ metadataPolicyAttributeTypeDescription `json:"-" xml:"-"`
+}
+
+type metadataPolicyAttributeTypeDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy.
+type PolicyDescription struct {
+ // The policy attributes.
+ PolicyAttributeDescriptions []*PolicyAttributeDescription `type:"list"`
+
+ // The name of the policy.
+ PolicyName *string `type:"string"`
+
+ // The name of the policy type.
+ PolicyTypeName *string `type:"string"`
+
+ metadataPolicyDescription `json:"-" xml:"-"`
+}
+
+type metadataPolicyDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a policy type.
+type PolicyTypeDescription struct {
+ // A description of the policy type.
+ Description *string `type:"string"`
+
+ // The description of the policy attributes associated with the policies defined
+ // by Elastic Load Balancing.
+ PolicyAttributeTypeDescriptions []*PolicyAttributeTypeDescription `type:"list"`
+
+ // The name of the policy type.
+ PolicyTypeName *string `type:"string"`
+
+ metadataPolicyTypeDescription `json:"-" xml:"-"`
+}
+
+type metadataPolicyTypeDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type RegisterInstancesWithLoadBalancerInput struct {
+ // The IDs of the instances.
+ Instances []*Instance `type:"list" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ metadataRegisterInstancesWithLoadBalancerInput `json:"-" xml:"-"`
+}
+
+type metadataRegisterInstancesWithLoadBalancerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type RegisterInstancesWithLoadBalancerOutput struct {
+ // The updated list of instances for the load balancer.
+ Instances []*Instance `type:"list"`
+
+ metadataRegisterInstancesWithLoadBalancerOutput `json:"-" xml:"-"`
+}
+
+type metadataRegisterInstancesWithLoadBalancerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type RemoveTagsInput struct {
+ // The name of the load balancer. You can specify a maximum of one load balancer
+ // name.
+ LoadBalancerNames []*string `type:"list" required:"true"`
+
+ // The list of tag keys to remove.
+ Tags []*TagKeyOnly `type:"list" required:"true"`
+
+ metadataRemoveTagsInput `json:"-" xml:"-"`
+}
+
+type metadataRemoveTagsInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type RemoveTagsOutput struct {
+ metadataRemoveTagsOutput `json:"-" xml:"-"`
+}
+
+type metadataRemoveTagsOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerListenerSSLCertificateInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The port that uses the specified SSL certificate.
+ LoadBalancerPort *int64 `type:"integer" required:"true"`
+
+ // The Amazon Resource Name (ARN) of the SSL certificate.
+ SSLCertificateID *string `locationName:"SSLCertificateId" type:"string" required:"true"`
+
+ metadataSetLoadBalancerListenerSSLCertificateInput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerListenerSSLCertificateInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerListenerSSLCertificateOutput struct {
+ metadataSetLoadBalancerListenerSSLCertificateOutput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerListenerSSLCertificateOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerPoliciesForBackendServerInput struct {
+ // The port number associated with the back-end server.
+ InstancePort *int64 `type:"integer" required:"true"`
+
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The names of the policies. If the list is empty, then all current polices
+ // are removed from the back-end server.
+ PolicyNames []*string `type:"list" required:"true"`
+
+ metadataSetLoadBalancerPoliciesForBackendServerInput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerPoliciesForBackendServerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerPoliciesForBackendServerOutput struct {
+ metadataSetLoadBalancerPoliciesForBackendServerOutput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerPoliciesForBackendServerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerPoliciesOfListenerInput struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string" required:"true"`
+
+ // The external port of the load balancer for the policy.
+ LoadBalancerPort *int64 `type:"integer" required:"true"`
+
+ // The names of the policies. If the list is empty, the current policy is removed
+ // from the listener.
+ PolicyNames []*string `type:"list" required:"true"`
+
+ metadataSetLoadBalancerPoliciesOfListenerInput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerPoliciesOfListenerInput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+type SetLoadBalancerPoliciesOfListenerOutput struct {
+ metadataSetLoadBalancerPoliciesOfListenerOutput `json:"-" xml:"-"`
+}
+
+type metadataSetLoadBalancerPoliciesOfListenerOutput struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a source security group.
+type SourceSecurityGroup struct {
+ // The name of the security group.
+ GroupName *string `type:"string"`
+
+ // The owner of the security group.
+ OwnerAlias *string `type:"string"`
+
+ metadataSourceSecurityGroup `json:"-" xml:"-"`
+}
+
+type metadataSourceSecurityGroup struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// Information about a tag.
+type Tag struct {
+ // The key of the tag.
+ Key *string `type:"string" required:"true"`
+
+ // The value of the tag.
+ Value *string `type:"string"`
+
+ metadataTag `json:"-" xml:"-"`
+}
+
+type metadataTag struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The tags associated with a load balancer.
+type TagDescription struct {
+ // The name of the load balancer.
+ LoadBalancerName *string `type:"string"`
+
+ // The tags.
+ Tags []*Tag `type:"list"`
+
+ metadataTagDescription `json:"-" xml:"-"`
+}
+
+type metadataTagDescription struct {
+ SDKShapeTraits bool `type:"structure"`
+}
+
+// The key of a tag.
+type TagKeyOnly struct {
+ // The name of the key.
+ Key *string `type:"string"`
+
+ metadataTagKeyOnly `json:"-" xml:"-"`
+}
+
+type metadataTagKeyOnly struct {
+ SDKShapeTraits bool `type:"structure"`
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/elbiface/interface.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/elbiface/interface.go
new file mode 100644
index 00000000000..053a62c8e32
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/elbiface/interface.go
@@ -0,0 +1,63 @@
+package elbiface
+
+import (
+ "github.com/awslabs/aws-sdk-go/service/elb"
+)
+
+type ELBAPI interface {
+ AddTags(*elb.AddTagsInput) (*elb.AddTagsOutput, error)
+
+ ApplySecurityGroupsToLoadBalancer(*elb.ApplySecurityGroupsToLoadBalancerInput) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error)
+
+ AttachLoadBalancerToSubnets(*elb.AttachLoadBalancerToSubnetsInput) (*elb.AttachLoadBalancerToSubnetsOutput, error)
+
+ ConfigureHealthCheck(*elb.ConfigureHealthCheckInput) (*elb.ConfigureHealthCheckOutput, error)
+
+ CreateAppCookieStickinessPolicy(*elb.CreateAppCookieStickinessPolicyInput) (*elb.CreateAppCookieStickinessPolicyOutput, error)
+
+ CreateLBCookieStickinessPolicy(*elb.CreateLBCookieStickinessPolicyInput) (*elb.CreateLBCookieStickinessPolicyOutput, error)
+
+ CreateLoadBalancer(*elb.CreateLoadBalancerInput) (*elb.CreateLoadBalancerOutput, error)
+
+ CreateLoadBalancerListeners(*elb.CreateLoadBalancerListenersInput) (*elb.CreateLoadBalancerListenersOutput, error)
+
+ CreateLoadBalancerPolicy(*elb.CreateLoadBalancerPolicyInput) (*elb.CreateLoadBalancerPolicyOutput, error)
+
+ DeleteLoadBalancer(*elb.DeleteLoadBalancerInput) (*elb.DeleteLoadBalancerOutput, error)
+
+ DeleteLoadBalancerListeners(*elb.DeleteLoadBalancerListenersInput) (*elb.DeleteLoadBalancerListenersOutput, error)
+
+ DeleteLoadBalancerPolicy(*elb.DeleteLoadBalancerPolicyInput) (*elb.DeleteLoadBalancerPolicyOutput, error)
+
+ DeregisterInstancesFromLoadBalancer(*elb.DeregisterInstancesFromLoadBalancerInput) (*elb.DeregisterInstancesFromLoadBalancerOutput, error)
+
+ DescribeInstanceHealth(*elb.DescribeInstanceHealthInput) (*elb.DescribeInstanceHealthOutput, error)
+
+ DescribeLoadBalancerAttributes(*elb.DescribeLoadBalancerAttributesInput) (*elb.DescribeLoadBalancerAttributesOutput, error)
+
+ DescribeLoadBalancerPolicies(*elb.DescribeLoadBalancerPoliciesInput) (*elb.DescribeLoadBalancerPoliciesOutput, error)
+
+ DescribeLoadBalancerPolicyTypes(*elb.DescribeLoadBalancerPolicyTypesInput) (*elb.DescribeLoadBalancerPolicyTypesOutput, error)
+
+ DescribeLoadBalancers(*elb.DescribeLoadBalancersInput) (*elb.DescribeLoadBalancersOutput, error)
+
+ DescribeTags(*elb.DescribeTagsInput) (*elb.DescribeTagsOutput, error)
+
+ DetachLoadBalancerFromSubnets(*elb.DetachLoadBalancerFromSubnetsInput) (*elb.DetachLoadBalancerFromSubnetsOutput, error)
+
+ DisableAvailabilityZonesForLoadBalancer(*elb.DisableAvailabilityZonesForLoadBalancerInput) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error)
+
+ EnableAvailabilityZonesForLoadBalancer(*elb.EnableAvailabilityZonesForLoadBalancerInput) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error)
+
+ ModifyLoadBalancerAttributes(*elb.ModifyLoadBalancerAttributesInput) (*elb.ModifyLoadBalancerAttributesOutput, error)
+
+ RegisterInstancesWithLoadBalancer(*elb.RegisterInstancesWithLoadBalancerInput) (*elb.RegisterInstancesWithLoadBalancerOutput, error)
+
+ RemoveTags(*elb.RemoveTagsInput) (*elb.RemoveTagsOutput, error)
+
+ SetLoadBalancerListenerSSLCertificate(*elb.SetLoadBalancerListenerSSLCertificateInput) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error)
+
+ SetLoadBalancerPoliciesForBackendServer(*elb.SetLoadBalancerPoliciesForBackendServerInput) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error)
+
+ SetLoadBalancerPoliciesOfListener(*elb.SetLoadBalancerPoliciesOfListenerInput) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error)
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/examples_test.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/examples_test.go
new file mode 100644
index 00000000000..7c25ba31f73
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/examples_test.go
@@ -0,0 +1,748 @@
+package elb_test
+
+import (
+ "bytes"
+ "fmt"
+ "time"
+
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/aws/awsutil"
+ "github.com/awslabs/aws-sdk-go/service/elb"
+)
+
+var _ time.Duration
+var _ bytes.Buffer
+
+func ExampleELB_AddTags() {
+ svc := elb.New(nil)
+
+ params := &elb.AddTagsInput{
+ LoadBalancerNames: []*string{ // Required
+ aws.String("AccessPointName"), // Required
+ // More values...
+ },
+ Tags: []*elb.Tag{ // Required
+ &elb.Tag{ // Required
+ Key: aws.String("TagKey"), // Required
+ Value: aws.String("TagValue"),
+ },
+ // More values...
+ },
+ }
+ resp, err := svc.AddTags(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_ApplySecurityGroupsToLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.ApplySecurityGroupsToLoadBalancerInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ SecurityGroups: []*string{ // Required
+ aws.String("SecurityGroupId"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.ApplySecurityGroupsToLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_AttachLoadBalancerToSubnets() {
+ svc := elb.New(nil)
+
+ params := &elb.AttachLoadBalancerToSubnetsInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ Subnets: []*string{ // Required
+ aws.String("SubnetId"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.AttachLoadBalancerToSubnets(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_ConfigureHealthCheck() {
+ svc := elb.New(nil)
+
+ params := &elb.ConfigureHealthCheckInput{
+ HealthCheck: &elb.HealthCheck{ // Required
+ HealthyThreshold: aws.Long(1), // Required
+ Interval: aws.Long(1), // Required
+ Target: aws.String("HealthCheckTarget"), // Required
+ Timeout: aws.Long(1), // Required
+ UnhealthyThreshold: aws.Long(1), // Required
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.ConfigureHealthCheck(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_CreateAppCookieStickinessPolicy() {
+ svc := elb.New(nil)
+
+ params := &elb.CreateAppCookieStickinessPolicyInput{
+ CookieName: aws.String("CookieName"), // Required
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ PolicyName: aws.String("PolicyName"), // Required
+ }
+ resp, err := svc.CreateAppCookieStickinessPolicy(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_CreateLBCookieStickinessPolicy() {
+ svc := elb.New(nil)
+
+ params := &elb.CreateLBCookieStickinessPolicyInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ PolicyName: aws.String("PolicyName"), // Required
+ CookieExpirationPeriod: aws.Long(1),
+ }
+ resp, err := svc.CreateLBCookieStickinessPolicy(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_CreateLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.CreateLoadBalancerInput{
+ Listeners: []*elb.Listener{ // Required
+ &elb.Listener{ // Required
+ InstancePort: aws.Long(1), // Required
+ LoadBalancerPort: aws.Long(1), // Required
+ Protocol: aws.String("Protocol"), // Required
+ InstanceProtocol: aws.String("Protocol"),
+ SSLCertificateID: aws.String("SSLCertificateId"),
+ },
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ AvailabilityZones: []*string{
+ aws.String("AvailabilityZone"), // Required
+ // More values...
+ },
+ Scheme: aws.String("LoadBalancerScheme"),
+ SecurityGroups: []*string{
+ aws.String("SecurityGroupId"), // Required
+ // More values...
+ },
+ Subnets: []*string{
+ aws.String("SubnetId"), // Required
+ // More values...
+ },
+ Tags: []*elb.Tag{
+ &elb.Tag{ // Required
+ Key: aws.String("TagKey"), // Required
+ Value: aws.String("TagValue"),
+ },
+ // More values...
+ },
+ }
+ resp, err := svc.CreateLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_CreateLoadBalancerListeners() {
+ svc := elb.New(nil)
+
+ params := &elb.CreateLoadBalancerListenersInput{
+ Listeners: []*elb.Listener{ // Required
+ &elb.Listener{ // Required
+ InstancePort: aws.Long(1), // Required
+ LoadBalancerPort: aws.Long(1), // Required
+ Protocol: aws.String("Protocol"), // Required
+ InstanceProtocol: aws.String("Protocol"),
+ SSLCertificateID: aws.String("SSLCertificateId"),
+ },
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.CreateLoadBalancerListeners(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_CreateLoadBalancerPolicy() {
+ svc := elb.New(nil)
+
+ params := &elb.CreateLoadBalancerPolicyInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ PolicyName: aws.String("PolicyName"), // Required
+ PolicyTypeName: aws.String("PolicyTypeName"), // Required
+ PolicyAttributes: []*elb.PolicyAttribute{
+ &elb.PolicyAttribute{ // Required
+ AttributeName: aws.String("AttributeName"),
+ AttributeValue: aws.String("AttributeValue"),
+ },
+ // More values...
+ },
+ }
+ resp, err := svc.CreateLoadBalancerPolicy(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DeleteLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.DeleteLoadBalancerInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.DeleteLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DeleteLoadBalancerListeners() {
+ svc := elb.New(nil)
+
+ params := &elb.DeleteLoadBalancerListenersInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ LoadBalancerPorts: []*int64{ // Required
+ aws.Long(1), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.DeleteLoadBalancerListeners(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DeleteLoadBalancerPolicy() {
+ svc := elb.New(nil)
+
+ params := &elb.DeleteLoadBalancerPolicyInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ PolicyName: aws.String("PolicyName"), // Required
+ }
+ resp, err := svc.DeleteLoadBalancerPolicy(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DeregisterInstancesFromLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.DeregisterInstancesFromLoadBalancerInput{
+ Instances: []*elb.Instance{ // Required
+ &elb.Instance{ // Required
+ InstanceID: aws.String("InstanceId"),
+ },
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.DeregisterInstancesFromLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeInstanceHealth() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeInstanceHealthInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ Instances: []*elb.Instance{
+ &elb.Instance{ // Required
+ InstanceID: aws.String("InstanceId"),
+ },
+ // More values...
+ },
+ }
+ resp, err := svc.DescribeInstanceHealth(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeLoadBalancerAttributes() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeLoadBalancerAttributesInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.DescribeLoadBalancerAttributes(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeLoadBalancerPolicies() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeLoadBalancerPoliciesInput{
+ LoadBalancerName: aws.String("AccessPointName"),
+ PolicyNames: []*string{
+ aws.String("PolicyName"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.DescribeLoadBalancerPolicies(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeLoadBalancerPolicyTypes() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeLoadBalancerPolicyTypesInput{
+ PolicyTypeNames: []*string{
+ aws.String("PolicyTypeName"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.DescribeLoadBalancerPolicyTypes(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeLoadBalancers() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeLoadBalancersInput{
+ LoadBalancerNames: []*string{
+ aws.String("AccessPointName"), // Required
+ // More values...
+ },
+ Marker: aws.String("Marker"),
+ PageSize: aws.Long(1),
+ }
+ resp, err := svc.DescribeLoadBalancers(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DescribeTags() {
+ svc := elb.New(nil)
+
+ params := &elb.DescribeTagsInput{
+ LoadBalancerNames: []*string{ // Required
+ aws.String("AccessPointName"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.DescribeTags(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DetachLoadBalancerFromSubnets() {
+ svc := elb.New(nil)
+
+ params := &elb.DetachLoadBalancerFromSubnetsInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ Subnets: []*string{ // Required
+ aws.String("SubnetId"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.DetachLoadBalancerFromSubnets(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_DisableAvailabilityZonesForLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.DisableAvailabilityZonesForLoadBalancerInput{
+ AvailabilityZones: []*string{ // Required
+ aws.String("AvailabilityZone"), // Required
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.DisableAvailabilityZonesForLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_EnableAvailabilityZonesForLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.EnableAvailabilityZonesForLoadBalancerInput{
+ AvailabilityZones: []*string{ // Required
+ aws.String("AvailabilityZone"), // Required
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.EnableAvailabilityZonesForLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_ModifyLoadBalancerAttributes() {
+ svc := elb.New(nil)
+
+ params := &elb.ModifyLoadBalancerAttributesInput{
+ LoadBalancerAttributes: &elb.LoadBalancerAttributes{ // Required
+ AccessLog: &elb.AccessLog{
+ Enabled: aws.Boolean(true), // Required
+ EmitInterval: aws.Long(1),
+ S3BucketName: aws.String("S3BucketName"),
+ S3BucketPrefix: aws.String("AccessLogPrefix"),
+ },
+ AdditionalAttributes: []*elb.AdditionalAttribute{
+ &elb.AdditionalAttribute{ // Required
+ Key: aws.String("StringVal"),
+ Value: aws.String("StringVal"),
+ },
+ // More values...
+ },
+ ConnectionDraining: &elb.ConnectionDraining{
+ Enabled: aws.Boolean(true), // Required
+ Timeout: aws.Long(1),
+ },
+ ConnectionSettings: &elb.ConnectionSettings{
+ IdleTimeout: aws.Long(1), // Required
+ },
+ CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{
+ Enabled: aws.Boolean(true), // Required
+ },
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.ModifyLoadBalancerAttributes(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_RegisterInstancesWithLoadBalancer() {
+ svc := elb.New(nil)
+
+ params := &elb.RegisterInstancesWithLoadBalancerInput{
+ Instances: []*elb.Instance{ // Required
+ &elb.Instance{ // Required
+ InstanceID: aws.String("InstanceId"),
+ },
+ // More values...
+ },
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ }
+ resp, err := svc.RegisterInstancesWithLoadBalancer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_RemoveTags() {
+ svc := elb.New(nil)
+
+ params := &elb.RemoveTagsInput{
+ LoadBalancerNames: []*string{ // Required
+ aws.String("AccessPointName"), // Required
+ // More values...
+ },
+ Tags: []*elb.TagKeyOnly{ // Required
+ &elb.TagKeyOnly{ // Required
+ Key: aws.String("TagKey"),
+ },
+ // More values...
+ },
+ }
+ resp, err := svc.RemoveTags(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_SetLoadBalancerListenerSSLCertificate() {
+ svc := elb.New(nil)
+
+ params := &elb.SetLoadBalancerListenerSSLCertificateInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ LoadBalancerPort: aws.Long(1), // Required
+ SSLCertificateID: aws.String("SSLCertificateId"), // Required
+ }
+ resp, err := svc.SetLoadBalancerListenerSSLCertificate(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_SetLoadBalancerPoliciesForBackendServer() {
+ svc := elb.New(nil)
+
+ params := &elb.SetLoadBalancerPoliciesForBackendServerInput{
+ InstancePort: aws.Long(1), // Required
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ PolicyNames: []*string{ // Required
+ aws.String("PolicyName"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.SetLoadBalancerPoliciesForBackendServer(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
+
+func ExampleELB_SetLoadBalancerPoliciesOfListener() {
+ svc := elb.New(nil)
+
+ params := &elb.SetLoadBalancerPoliciesOfListenerInput{
+ LoadBalancerName: aws.String("AccessPointName"), // Required
+ LoadBalancerPort: aws.Long(1), // Required
+ PolicyNames: []*string{ // Required
+ aws.String("PolicyName"), // Required
+ // More values...
+ },
+ }
+ resp, err := svc.SetLoadBalancerPoliciesOfListener(params)
+
+ if awserr := aws.Error(err); awserr != nil {
+ // A service error occurred.
+ fmt.Println("Error:", awserr.Code, awserr.Message)
+ } else if err != nil {
+ // A non-service error occurred.
+ panic(err)
+ }
+
+ // Pretty-print the response data.
+ fmt.Println(awsutil.StringValue(resp))
+}
diff --git a/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/service.go b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/service.go
new file mode 100644
index 00000000000..b578a08b11a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/awslabs/aws-sdk-go/service/elb/service.go
@@ -0,0 +1,59 @@
+package elb
+
+import (
+ "github.com/awslabs/aws-sdk-go/aws"
+ "github.com/awslabs/aws-sdk-go/internal/protocol/query"
+ "github.com/awslabs/aws-sdk-go/internal/signer/v4"
+)
+
+// ELB is a client for Elastic Load Balancing.
+type ELB struct {
+ *aws.Service
+}
+
+// Used for custom service initialization logic
+var initService func(*aws.Service)
+
+// Used for custom request initialization logic
+var initRequest func(*aws.Request)
+
+// New returns a new ELB client.
+func New(config *aws.Config) *ELB {
+ if config == nil {
+ config = &aws.Config{}
+ }
+
+ service := &aws.Service{
+ Config: aws.DefaultConfig.Merge(config),
+ ServiceName: "elasticloadbalancing",
+ APIVersion: "2012-06-01",
+ }
+ service.Initialize()
+
+ // Handlers
+ service.Handlers.Sign.PushBack(v4.Sign)
+ service.Handlers.Build.PushBack(query.Build)
+ service.Handlers.Unmarshal.PushBack(query.Unmarshal)
+ service.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
+ service.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
+
+ // Run custom service initialization if present
+ if initService != nil {
+ initService(service)
+ }
+
+ return &ELB{service}
+}
+
+// newRequest creates a new request for a ELB operation and runs any
+// custom request initialization.
+func (c *ELB) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
+ req := aws.NewRequest(c.Service, op, params, data)
+
+ // Run custom request initialization if present
+ if initRequest != nil {
+ initRequest(req)
+ }
+
+ return req
+}