func ExampleSQS_ReceiveMessage() { svc := sqs.New(session.New()) params := &sqs.ReceiveMessageInput{ QueueUrl: aws.String("String"), // Required AttributeNames: []*string{ aws.String("QueueAttributeName"), // Required // More values... }, MaxNumberOfMessages: aws.Int64(1), MessageAttributeNames: []*string{ aws.String("MessageAttributeName"), // Required // More values... }, VisibilityTimeout: aws.Int64(1), WaitTimeSeconds: aws.Int64(1), } resp, err := svc.ReceiveMessage(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func (infra *Infrastructure) createIAMLambdaRolePolicy(roleName string) error { svc := iam.New(session.New(), infra.config) _, err := svc.PutRolePolicy(&iam.PutRolePolicyInput{ PolicyDocument: aws.String(`{ "Version": "2012-10-17", "Statement": [ { "Action": [ "sqs:SendMessage" ], "Effect": "Allow", "Resource": "arn:aws:sqs:*:*:goad-*" }, { "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Effect": "Allow", "Resource": "arn:aws:logs:*:*:*" } ] }`), PolicyName: aws.String("goad-lambda-role-policy"), RoleName: aws.String(roleName), }) return err }
func ExampleSQS_ChangeMessageVisibilityBatch() { svc := sqs.New(session.New()) params := &sqs.ChangeMessageVisibilityBatchInput{ Entries: []*sqs.ChangeMessageVisibilityBatchRequestEntry{ // Required { // Required Id: aws.String("String"), // Required ReceiptHandle: aws.String("String"), // Required VisibilityTimeout: aws.Int64(1), }, // More values... }, QueueUrl: aws.String("String"), // Required } resp, err := svc.ChangeMessageVisibilityBatch(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
// Retrieve generates a new set of temporary credentials using STS. func (p *AssumeRoleProvider) Retrieve() (credentials.Value, error) { // Apply defaults where parameters are not set. if p.RoleSessionName == "" { // Try to work out a role name that will hopefully end up unique. p.RoleSessionName = fmt.Sprintf("%d", time.Now().UTC().UnixNano()) } if p.Duration == 0 { // Expire as often as AWS permits. p.Duration = DefaultDuration } roleOutput, err := p.Client.AssumeRole(&sts.AssumeRoleInput{ DurationSeconds: aws.Int64(int64(p.Duration / time.Second)), RoleArn: aws.String(p.RoleARN), RoleSessionName: aws.String(p.RoleSessionName), ExternalId: p.ExternalID, }) if err != nil { return credentials.Value{}, err } // We will proactively generate new credentials before they expire. p.SetExpiration(*roleOutput.Credentials.Expiration, p.ExpiryWindow) return credentials.Value{ AccessKeyID: *roleOutput.Credentials.AccessKeyId, SecretAccessKey: *roleOutput.Credentials.SecretAccessKey, SessionToken: *roleOutput.Credentials.SessionToken, }, nil }
func TestInputService5ProtocolTestRecursiveShapesCase3(t *testing.T) { sess := session.New() svc := NewInputService5ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputShape{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, }, }, } req, _ := svc.InputService5TestCaseOperation3Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct":{"RecursiveStruct":{"RecursiveStruct":{"RecursiveStruct":{"NoRecurse":"foo"}}}}}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func ExampleSQS_AddPermission() { svc := sqs.New(session.New()) params := &sqs.AddPermissionInput{ AWSAccountIds: []*string{ // Required aws.String("String"), // Required // More values... }, Actions: []*string{ // Required aws.String("String"), // Required // More values... }, Label: aws.String("String"), // Required QueueUrl: aws.String("String"), // Required } resp, err := svc.AddPermission(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func TestPresignHandler(t *testing.T) { svc := s3.New(unit.Session) req, _ := svc.PutObjectRequest(&s3.PutObjectInput{ Bucket: aws.String("bucket"), Key: aws.String("key"), ContentDisposition: aws.String("a+b c$d"), ACL: aws.String("public-read"), }) req.Time = time.Unix(0, 0) urlstr, err := req.Presign(5 * time.Minute) assert.NoError(t, err) expectedDate := "19700101T000000Z" expectedHeaders := "host;x-amz-acl" expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2" expectedCred := "AKID/19700101/mock-region/s3/aws4_request" u, _ := url.Parse(urlstr) urlQ := u.Query() assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature")) assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential")) assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders")) assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date")) assert.Equal(t, "300", urlQ.Get("X-Amz-Expires")) assert.NotContains(t, urlstr, "+") // + encoded as %20 }
func (s *stubSTS) AssumeRole(input *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) { expiry := time.Now().Add(60 * time.Minute) return &sts.AssumeRoleOutput{ Credentials: &sts.Credentials{ // Just reflect the role arn to the provider. AccessKeyId: input.RoleArn, SecretAccessKey: aws.String("assumedSecretAccessKey"), SessionToken: aws.String("assumedSessionToken"), Expiration: &expiry, }, }, nil }
// Use DynamoDB methods for simplicity func TestPaginationEachPage(t *testing.T) { db := dynamodb.New(unit.Session) tokens, pages, numPages, gotToEnd := []string{}, []string{}, 0, false reqNum := 0 resps := []*dynamodb.ListTablesOutput{ {TableNames: []*string{aws.String("Table1"), aws.String("Table2")}, LastEvaluatedTableName: aws.String("Table2")}, {TableNames: []*string{aws.String("Table3"), aws.String("Table4")}, LastEvaluatedTableName: aws.String("Table4")}, {TableNames: []*string{aws.String("Table5")}}, } db.Handlers.Send.Clear() // mock sending db.Handlers.Unmarshal.Clear() db.Handlers.UnmarshalMeta.Clear() db.Handlers.ValidateResponse.Clear() db.Handlers.Build.PushBack(func(r *request.Request) { in := r.Params.(*dynamodb.ListTablesInput) if in == nil { tokens = append(tokens, "") } else if in.ExclusiveStartTableName != nil { tokens = append(tokens, *in.ExclusiveStartTableName) } }) db.Handlers.Unmarshal.PushBack(func(r *request.Request) { r.Data = resps[reqNum] reqNum++ }) params := &dynamodb.ListTablesInput{Limit: aws.Int64(2)} req, _ := db.ListTablesRequest(params) err := req.EachPage(func(p interface{}, last bool) bool { numPages++ for _, t := range p.(*dynamodb.ListTablesOutput).TableNames { pages = append(pages, *t) } if last { if gotToEnd { assert.Fail(t, "last=true happened twice") } gotToEnd = true } return true }) assert.Equal(t, []string{"Table2", "Table4"}, tokens) assert.Equal(t, []string{"Table1", "Table2", "Table3", "Table4", "Table5"}, pages) assert.Equal(t, 3, numPages) assert.True(t, gotToEnd) assert.Nil(t, err) }
func ExampleLambda_CreateFunction() { svc := lambda.New(session.New()) params := &lambda.CreateFunctionInput{ Code: &lambda.FunctionCode{ // Required S3Bucket: aws.String("S3Bucket"), S3Key: aws.String("S3Key"), S3ObjectVersion: aws.String("S3ObjectVersion"), ZipFile: []byte("PAYLOAD"), }, FunctionName: aws.String("FunctionName"), // Required Handler: aws.String("Handler"), // Required Role: aws.String("RoleArn"), // Required Runtime: aws.String("Runtime"), // Required Description: aws.String("Description"), MemorySize: aws.Int64(1), Publish: aws.Bool(true), Timeout: aws.Int64(1), } resp, err := svc.CreateFunction(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func BenchmarkEncodingJSONMarshal_Simple_elastictranscoderListJobsByPipeline(b *testing.B) { params := &elastictranscoder.ListJobsByPipelineInput{ PipelineId: aws.String("Id"), // Required Ascending: aws.String("Ascending"), PageToken: aws.String("Id"), } for i := 0; i < b.N; i++ { buf := &bytes.Buffer{} encoder := json.NewEncoder(buf) if err := encoder.Encode(params); err != nil { b.Fatal("Unexpected error", err) } } }
func TestSendMessageChecksum(t *testing.T) { req, _ := svc.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("098f6bcd4621d373cade4e832627b4f6"), MessageId: aws.String("12345"), } }) err := req.Send() assert.NoError(t, err) }
func TestNoErrors(t *testing.T) { input := &StructShape{ RequiredList: []*ConditionalStructShape{}, RequiredMap: map[string]*ConditionalStructShape{ "key1": {Name: aws.String("Name")}, "key2": {Name: aws.String("Name")}, }, RequiredBool: aws.Bool(true), OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")}, } req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) require.NoError(t, req.Error) }
func TestOutputService9ProtocolTestSupportsHeaderMapsCase1(t *testing.T) { sess := session.New() svc := NewOutputService9ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{}")) req, out := svc.OutputService9TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("Content-Length", "10") req.HTTPResponse.Header.Set("X-Bam", "boo") req.HTTPResponse.Header.Set("X-Foo", "bar") // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "10", *out.AllHeaders["Content-Length"]) assert.Equal(t, "boo", *out.AllHeaders["X-Bam"]) assert.Equal(t, "bar", *out.AllHeaders["X-Foo"]) assert.Equal(t, "boo", *out.PrefixedHeaders["Bam"]) assert.Equal(t, "bar", *out.PrefixedHeaders["Foo"]) }
func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) { sess := session.New() svc := NewOutputService1ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"Str\": \"myname\", \"Num\": 123, \"FalseBool\": false, \"TrueBool\": true, \"Float\": 1.2, \"Double\": 1.3, \"Long\": 200, \"Char\": \"a\"}")) req, out := svc.OutputService1TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("ImaHeader", "test") req.HTTPResponse.Header.Set("X-Foo", "abc") // unmarshal response restjson.UnmarshalMeta(req) restjson.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, "test", *out.ImaHeader) assert.Equal(t, "abc", *out.ImaHeaderLocation) assert.Equal(t, int64(200), *out.Long) assert.Equal(t, int64(123), *out.Num) assert.Equal(t, int64(200), *out.Status) assert.Equal(t, "myname", *out.Str) assert.Equal(t, true, *out.TrueBool) }
func TestOutputService4ProtocolTestListsCase2(t *testing.T) { sess := session.New() svc := NewOutputService4ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [\"a\", null], \"ListMemberMap\": [{}, null, null, {}], \"ListMemberStruct\": [{}, null, null, {}]}")) req, out := svc.OutputService4TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response jsonrpc.UnmarshalMeta(req) jsonrpc.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "a", *out.ListMember[0]) assert.Nil(t, out.ListMember[1]) assert.Nil(t, out.ListMemberMap[1]) assert.Nil(t, out.ListMemberMap[2]) assert.Nil(t, out.ListMemberStruct[1]) assert.Nil(t, out.ListMemberStruct[2]) }
func TestInputService2ProtocolTestTimestampValuesCase1(t *testing.T) { sess := session.New() svc := NewInputService2ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService2TestShapeInputService2TestCaseOperation1Input{ TimeArg: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService2TestCaseOperation1Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"TimeArg":1422172800}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func TestInputService4ProtocolTestNestedBlobsCase1(t *testing.T) { sess := session.New() svc := NewInputService4ProtocolTest(sess, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService4TestShapeInputService4TestCaseOperation1Input{ ListParam: [][]byte{ []byte("foo"), []byte("bar"), }, } req, _ := svc.InputService4TestCaseOperation1Request(input) r := req.HTTPRequest // build request jsonrpc.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"ListParam":["Zm9v","YmFy"]}`, util.Trim(string(body))) // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "application/x-amz-json-1.1", r.Header.Get("Content-Type")) assert.Equal(t, "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target")) }
func TestEC2RoleProviderExpiryWindowIsExpired(t *testing.T) { server := initTestServer("2014-12-16T01:51:37Z", false) defer server.Close() p := &ec2rolecreds.EC2RoleProvider{ Client: ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")}), ExpiryWindow: time.Hour * 1, } p.CurrentTime = func() time.Time { return time.Date(2014, 12, 15, 0, 51, 37, 0, time.UTC) } assert.True(t, p.IsExpired(), "Expect creds to be expired before retrieve.") _, err := p.Retrieve() assert.Nil(t, err, "Expect no error, %v", err) assert.False(t, p.IsExpired(), "Expect creds to not be expired after retrieve.") p.CurrentTime = func() time.Time { return time.Date(2014, 12, 16, 0, 55, 37, 0, time.UTC) } assert.True(t, p.IsExpired(), "Expect creds to be expired.") }
func TestFlattenedTraits(t *testing.T) { s := sqs.New(session.New()) _, err := s.DeleteMessageBatch(&sqs.DeleteMessageBatchInput{ QueueURL: aws.String("QUEUE"), Entries: []*sqs.DeleteMessageBatchRequestEntry{ { ID: aws.String("TEST"), ReceiptHandle: aws.String("RECEIPT"), }, }, }) assert.Error(t, err) assert.Equal(t, "InvalidAddress", err.Code()) assert.Equal(t, "The address QUEUE is not valid for this endpoint.", err.Message()) }
func (infra *Infrastructure) removeSQSQueue() { svc := sqs.New(session.New(), infra.config) svc.DeleteQueue(&sqs.DeleteQueueInput{ QueueUrl: aws.String(infra.queueURL), }) }
// SendResult adds a result to the queue func (adaptor SQSAdaptor) SendResult(result AggData) { str, jsonerr := jsonFromResult(result) if jsonerr != nil { fmt.Println(jsonerr) return } params := &sqs.SendMessageInput{ MessageBody: aws.String(str), QueueUrl: aws.String(adaptor.QueueURL), } _, err := adaptor.Client.SendMessage(params) if err != nil { fmt.Println(err.Error()) return } }
func TestNewDefaultSession(t *testing.T) { s := session.New(&aws.Config{Region: aws.String("region")}) assert.Equal(t, "region", *s.Config.Region) assert.Equal(t, http.DefaultClient, s.Config.HTTPClient) assert.NotNil(t, s.Config.Logger) assert.Equal(t, aws.LogOff, *s.Config.LogLevel) }
func TestSendMessageChecksumInvalid(t *testing.T) { req, _ := svc.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("000"), MessageId: aws.String("12345"), } }) err := req.Send() assert.Error(t, err) assert.Equal(t, "InvalidChecksum", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "expected MD5 checksum '000', got '098f6bcd4621d373cade4e832627b4f6'") }
func TestRecieveMessageChecksum(t *testing.T) { req, _ := svc.ReceiveMessageRequest(&sqs.ReceiveMessageInput{}) req.Handlers.Send.PushBack(func(r *request.Request) { md5 := "098f6bcd4621d373cade4e832627b4f6" body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.ReceiveMessageOutput{ Messages: []*sqs.Message{ {Body: aws.String("test"), MD5OfBody: &md5}, {Body: aws.String("test"), MD5OfBody: &md5}, {Body: aws.String("test"), MD5OfBody: &md5}, {Body: aws.String("test"), MD5OfBody: &md5}, }, } }) err := req.Send() assert.NoError(t, err) }
// Use S3 for simplicity func TestPaginationTruncation(t *testing.T) { client := s3.New(unit.Session) reqNum := 0 resps := []*s3.ListObjectsOutput{ {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key1")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key2")}}}, {IsTruncated: aws.Bool(false), Contents: []*s3.Object{{Key: aws.String("Key3")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key4")}}}, } client.Handlers.Send.Clear() // mock sending client.Handlers.Unmarshal.Clear() client.Handlers.UnmarshalMeta.Clear() client.Handlers.ValidateResponse.Clear() client.Handlers.Unmarshal.PushBack(func(r *request.Request) { r.Data = resps[reqNum] reqNum++ }) params := &s3.ListObjectsInput{Bucket: aws.String("bucket")} results := []string{} err := client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2", "Key3"}, results) assert.Nil(t, err) // Try again without truncation token at all reqNum = 0 resps[1].IsTruncated = nil resps[2].IsTruncated = aws.Bool(true) results = []string{} err = client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2"}, results) assert.Nil(t, err) }
func TestDeepEqual(t *testing.T) { cases := []struct { a, b interface{} equal bool }{ {"a", "a", true}, {"a", "b", false}, {"a", aws.String(""), false}, {"a", nil, false}, {"a", aws.String("a"), true}, {(*bool)(nil), (*bool)(nil), true}, {(*bool)(nil), (*string)(nil), false}, {nil, nil, true}, } for i, c := range cases { assert.Equal(t, c.equal, awsutil.DeepEqual(c.a, c.b), "%d, a:%v b:%v, %t", i, c.a, c.b, c.equal) } }
func ExampleLambda_GetPolicy() { svc := lambda.New(session.New()) params := &lambda.GetPolicyInput{ FunctionName: aws.String("FunctionName"), // Required Qualifier: aws.String("Qualifier"), } resp, err := svc.GetPolicy(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleLambda_DeleteAlias() { svc := lambda.New(session.New()) params := &lambda.DeleteAliasInput{ FunctionName: aws.String("FunctionName"), // Required Name: aws.String("Alias"), // Required } resp, err := svc.DeleteAlias(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func (t *Test) invokeLambda(awsConfig *aws.Config, args invokeArgs) { svc := lambda.New(session.New(), awsConfig) j, _ := json.Marshal(args) svc.InvokeAsync(&lambda.InvokeAsyncInput{ FunctionName: aws.String("goad"), InvokeArgs: bytes.NewReader(j), }) }