kubernetes
/
kops
mirror of https://github.com/kubernetes/kops.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4569 from justinsb/mock_aws_roundtrip 

Create lifecycle test against AWS mocks
This commit is contained in:
k8s-ci-robot 2018-03-11 16:11:10 -07:00 committed by GitHub
parent d5c587c5d1 f254c38944
commit 994a348cb4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
44 changed files with 3943 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Gopkg.lock generated
View File

@ -114,6 +114,7 @@
"service/elb/elbiface",
"service/elbv2",
"service/iam",
"service/iam/iamiface",
"service/kms",
"service/route53",
"service/route53/route53iface",
@ -1541,6 +1542,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "7445d8b26618a25cff0c477f71b45cfe1c66c213599a07c2c751ad94ee64e86d"
inputs-digest = "08b9c9892557af4ea36c5173c564d6aac7cec6cdedd4a149ee74681d93dde51e"
solver-name = "gps-cdcl"
solver-version = 1

2
cloudmock/aws/mockautoscaling/BUILD.bazel
View File

@ -5,6 +5,7 @@ go_library(
srcs = [
"api.go",
"group.go",
"launchconfigurations.go",
"unimplemented.go",
],
importpath = "k8s.io/kops/cloudmock/aws/mockautoscaling",
@ -14,5 +15,6 @@ go_library(
"//vendor/github.com/aws/aws-sdk-go/aws/request:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/autoscaling:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface:go_default_library",
"//vendor/github.com/golang/glog:go_default_library",
],
)

7
cloudmock/aws/mockautoscaling/api.go
View File

@ -17,12 +17,17 @@ limitations under the License.
package mockautoscaling
import (
"sync"
"github.com/aws/aws-sdk-go/service/autoscaling"
"github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface"
)
type MockAutoscaling struct {
Groups []*autoscaling.Group
mutex sync.Mutex
Groups map[string]*autoscaling.Group
LaunchConfigurations map[string]*autoscaling.LaunchConfiguration
}
var _ autoscalingiface.AutoScalingAPI = &MockAutoscaling{}

161
cloudmock/aws/mockautoscaling/group.go
View File

@ -18,52 +18,129 @@ package mockautoscaling
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/autoscaling"
"github.com/golang/glog"
)
func (m *MockAutoscaling) AttachInstances(input *autoscaling.AttachInstancesInput) (*autoscaling.AttachInstancesOutput, error) {
for _, group := range m.Groups {
if aws.StringValue(group.AutoScalingGroupName) == aws.StringValue(input.AutoScalingGroupName) {
for _, instanceID := range input.InstanceIds {
group.Instances = append(group.Instances, &autoscaling.Instance{InstanceId: instanceID})
}
}
m.mutex.Lock()
defer m.mutex.Unlock()
glog.V(2).Infof("AttachInstances %v", input)
g := m.Groups[aws.StringValue(input.AutoScalingGroupName)]
if g == nil {
return nil, fmt.Errorf("AutoScaling Group not found")
}
return nil, nil
for _, instanceID := range input.InstanceIds {
g.Instances = append(g.Instances, &autoscaling.Instance{InstanceId: instanceID})
}
return &autoscaling.AttachInstancesOutput{}, nil
}
func (m *MockAutoscaling) CreateAutoScalingGroup(input *autoscaling.CreateAutoScalingGroupInput) (*autoscaling.CreateAutoScalingGroupOutput, error) {
newGroup := &autoscaling.Group{
m.mutex.Lock()
defer m.mutex.Unlock()
glog.V(2).Infof("CreateAutoScalingGroup %v", input)
createdTime := time.Now().UTC()
g := &autoscaling.Group{
AutoScalingGroupName: input.AutoScalingGroupName,
MinSize: input.MinSize,
MaxSize: input.MaxSize,
Instances: []*autoscaling.Instance{},
AvailabilityZones: input.AvailabilityZones,
CreatedTime: &createdTime,
DefaultCooldown: input.DefaultCooldown,
DesiredCapacity: input.DesiredCapacity,
// EnabledMetrics: input.EnabledMetrics,
HealthCheckGracePeriod: input.HealthCheckGracePeriod,
HealthCheckType: input.HealthCheckType,
Instances: []*autoscaling.Instance{},
LaunchConfigurationName: input.LaunchConfigurationName,
LoadBalancerNames: input.LoadBalancerNames,
MaxSize: input.MaxSize,
MinSize: input.MinSize,
NewInstancesProtectedFromScaleIn: input.NewInstancesProtectedFromScaleIn,
PlacementGroup: input.PlacementGroup,
// Status: input.Status,
// SuspendedProcesses: input.SuspendedProcesses,
// Tags: input.Tags,
TargetGroupARNs: input.TargetGroupARNs,
TerminationPolicies: input.TerminationPolicies,
VPCZoneIdentifier: input.VPCZoneIdentifier,
}
m.Groups = append(m.Groups, newGroup)
return nil, nil
for _, tag := range input.Tags {
g.Tags = append(g.Tags, &autoscaling.TagDescription{
Key: tag.Key,
PropagateAtLaunch: tag.PropagateAtLaunch,
ResourceId: tag.ResourceId,
ResourceType: tag.ResourceType,
Value: tag.Value,
})
}
if m.Groups == nil {
m.Groups = make(map[string]*autoscaling.Group)
}
m.Groups[*g.AutoScalingGroupName] = g
return &autoscaling.CreateAutoScalingGroupOutput{}, nil
}
func (m *MockAutoscaling) EnableMetricsCollection(input *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) {
return nil, nil
func (m *MockAutoscaling) EnableMetricsCollection(request *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("EnableMetricsCollection: %v", request)
g := m.Groups[*request.AutoScalingGroupName]
if g == nil {
return nil, fmt.Errorf("AutoScalingGroup not found")
}
metrics := make(map[string]*autoscaling.EnabledMetric)
for _, m := range g.EnabledMetrics {
metrics[*m.Metric] = m
}
for _, m := range request.Metrics {
metrics[*m] = &autoscaling.EnabledMetric{
Metric: m,
Granularity: request.Granularity,
}
}
g.EnabledMetrics = nil
for _, m := range metrics {
g.EnabledMetrics = append(g.EnabledMetrics, m)
}
response := &autoscaling.EnableMetricsCollectionOutput{}
return response, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroups(input *autoscaling.DescribeAutoScalingGroupsInput) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
if len(input.AutoScalingGroupNames) == 0 {
return &autoscaling.DescribeAutoScalingGroupsOutput{
AutoScalingGroups: m.Groups,
}, nil
}
groups := []*autoscaling.Group{}
for _, group := range m.Groups {
for _, inputGroupName := range input.AutoScalingGroupNames {
if aws.StringValue(group.AutoScalingGroupName) == aws.StringValue(inputGroupName) {
groups = append(groups, group)
match := false
if len(input.AutoScalingGroupNames) > 0 {
for _, inputGroupName := range input.AutoScalingGroupNames {
if aws.StringValue(group.AutoScalingGroupName) == aws.StringValue(inputGroupName) {
match = true
}
}
}
if match {
groups = append(groups, group)
}
}
return &autoscaling.DescribeAutoScalingGroupsOutput{
@ -76,10 +153,44 @@ func (m *MockAutoscaling) TerminateInstanceInAutoScalingGroup(input *autoscaling
for i := range group.Instances {
if aws.StringValue(group.Instances[i].InstanceId) == aws.StringValue(input.InstanceId) {
group.Instances = append(group.Instances[:i], group.Instances[i+1:]...)
return nil, nil
return &autoscaling.TerminateInstanceInAutoScalingGroupOutput{
Activity: nil, // TODO
}, nil
}
}
}
return nil, fmt.Errorf("Instance not found")
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, ...request.Option) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsRequest(*autoscaling.DescribeAutoScalingGroupsInput) (*request.Request, *autoscaling.DescribeAutoScalingGroupsOutput) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsPages(request *autoscaling.DescribeAutoScalingGroupsInput, callback func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool) error {
if request.MaxRecords != nil {
glog.Fatalf("MaxRecords not implemented")
}
if request.NextToken != nil {
glog.Fatalf("NextToken not implemented")
}
// For the mock, we just send everything in one page
page, err := m.DescribeAutoScalingGroups(request)
if err != nil {
return err
}
callback(page, false)
return nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsPagesWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool, ...request.Option) error {
glog.Fatalf("Not implemented")
return nil
}

108
cloudmock/aws/mockautoscaling/launchconfigurations.go Normal file
View File

@ -0,0 +1,108 @@
/*
Copyright 2016 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockautoscaling
import (
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/autoscaling"
"github.com/golang/glog"
)
func (m *MockAutoscaling) DescribeLaunchConfigurations(*autoscaling.DescribeLaunchConfigurationsInput) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsWithContext(aws.Context, *autoscaling.DescribeLaunchConfigurationsInput, ...request.Option) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsRequest(*autoscaling.DescribeLaunchConfigurationsInput) (*request.Request, *autoscaling.DescribeLaunchConfigurationsOutput) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsPages(request *autoscaling.DescribeLaunchConfigurationsInput, callback func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool) error {
if request.LaunchConfigurationNames != nil {
glog.Fatalf("LaunchConfigurationNames not implemented")
}
if request.MaxRecords != nil {
glog.Fatalf("MaxRecords not implemented")
}
if request.NextToken != nil {
glog.Fatalf("NextToken not implemented")
}
// For the mock, we just send everything in one page
page := &autoscaling.DescribeLaunchConfigurationsOutput{}
for _, lc := range m.LaunchConfigurations {
page.LaunchConfigurations = append(page.LaunchConfigurations, lc)
}
callback(page, false)
return nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsPagesWithContext(aws.Context, *autoscaling.DescribeLaunchConfigurationsInput, func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool, ...request.Option) error {
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) CreateLaunchConfiguration(request *autoscaling.CreateLaunchConfigurationInput) (*autoscaling.CreateLaunchConfigurationOutput, error) {
glog.Infof("CreateLaunchConfiguration: %v", request)
createdTime := time.Now().UTC()
lc := &autoscaling.LaunchConfiguration{
AssociatePublicIpAddress: request.AssociatePublicIpAddress,
BlockDeviceMappings: request.BlockDeviceMappings,
ClassicLinkVPCId: request.ClassicLinkVPCId,
ClassicLinkVPCSecurityGroups: request.ClassicLinkVPCSecurityGroups,
CreatedTime: &createdTime,
EbsOptimized: request.EbsOptimized,
IamInstanceProfile: request.IamInstanceProfile,
ImageId: request.ImageId,
InstanceMonitoring: request.InstanceMonitoring,
InstanceType: request.InstanceType,
KernelId: request.KernelId,
KeyName: request.KeyName,
// LaunchConfigurationARN: request.LaunchConfigurationARN,
LaunchConfigurationName: request.LaunchConfigurationName,
PlacementTenancy: request.PlacementTenancy,
RamdiskId: request.RamdiskId,
SecurityGroups: request.SecurityGroups,
SpotPrice: request.SpotPrice,
UserData: request.UserData,
}
if m.LaunchConfigurations == nil {
m.LaunchConfigurations = make(map[string]*autoscaling.LaunchConfiguration)
}
m.LaunchConfigurations[*lc.LaunchConfigurationName] = lc
return &autoscaling.CreateLaunchConfigurationOutput{}, nil
}
func (m *MockAutoscaling) CreateLaunchConfigurationWithContext(aws.Context, *autoscaling.CreateLaunchConfigurationInput, ...request.Option) (*autoscaling.CreateLaunchConfigurationOutput, error) {
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateLaunchConfigurationRequest(*autoscaling.CreateLaunchConfigurationInput) (*request.Request, *autoscaling.CreateLaunchConfigurationOutput) {
glog.Fatalf("Not implemented")
return nil, nil
}

378
cloudmock/aws/mockautoscaling/unimplemented.go
View File

@ -17,764 +17,710 @@ limitations under the License.
package mockautoscaling
import (
"log"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/autoscaling"
"github.com/golang/glog"
)
func (m *MockAutoscaling) AttachInstancesWithContext(aws.Context, *autoscaling.AttachInstancesInput, ...request.Option) (*autoscaling.AttachInstancesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachInstancesRequest(*autoscaling.AttachInstancesInput) (*request.Request, *autoscaling.AttachInstancesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancerTargetGroups(*autoscaling.AttachLoadBalancerTargetGroupsInput) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancerTargetGroupsWithContext(aws.Context, *autoscaling.AttachLoadBalancerTargetGroupsInput, ...request.Option) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancerTargetGroupsRequest(*autoscaling.AttachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.AttachLoadBalancerTargetGroupsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancers(*autoscaling.AttachLoadBalancersInput) (*autoscaling.AttachLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancersWithContext(aws.Context, *autoscaling.AttachLoadBalancersInput, ...request.Option) (*autoscaling.AttachLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) AttachLoadBalancersRequest(*autoscaling.AttachLoadBalancersInput) (*request.Request, *autoscaling.AttachLoadBalancersOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CompleteLifecycleAction(*autoscaling.CompleteLifecycleActionInput) (*autoscaling.CompleteLifecycleActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CompleteLifecycleActionWithContext(aws.Context, *autoscaling.CompleteLifecycleActionInput, ...request.Option) (*autoscaling.CompleteLifecycleActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CompleteLifecycleActionRequest(*autoscaling.CompleteLifecycleActionInput) (*request.Request, *autoscaling.CompleteLifecycleActionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateAutoScalingGroupWithContext(aws.Context, *autoscaling.CreateAutoScalingGroupInput, ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateAutoScalingGroupRequest(*autoscaling.CreateAutoScalingGroupInput) (*request.Request, *autoscaling.CreateAutoScalingGroupOutput) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateLaunchConfiguration(*autoscaling.CreateLaunchConfigurationInput) (*autoscaling.CreateLaunchConfigurationOutput, error) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateLaunchConfigurationWithContext(aws.Context, *autoscaling.CreateLaunchConfigurationInput, ...request.Option) (*autoscaling.CreateLaunchConfigurationOutput, error) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateLaunchConfigurationRequest(*autoscaling.CreateLaunchConfigurationInput) (*request.Request, *autoscaling.CreateLaunchConfigurationOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateOrUpdateTags(*autoscaling.CreateOrUpdateTagsInput) (*autoscaling.CreateOrUpdateTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateOrUpdateTagsWithContext(aws.Context, *autoscaling.CreateOrUpdateTagsInput, ...request.Option) (*autoscaling.CreateOrUpdateTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) CreateOrUpdateTagsRequest(*autoscaling.CreateOrUpdateTagsInput) (*request.Request, *autoscaling.CreateOrUpdateTagsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteAutoScalingGroup(*autoscaling.DeleteAutoScalingGroupInput) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteAutoScalingGroupWithContext(aws.Context, *autoscaling.DeleteAutoScalingGroupInput, ...request.Option) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteAutoScalingGroupRequest(*autoscaling.DeleteAutoScalingGroupInput) (*request.Request, *autoscaling.DeleteAutoScalingGroupOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLaunchConfiguration(*autoscaling.DeleteLaunchConfigurationInput) (*autoscaling.DeleteLaunchConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLaunchConfigurationWithContext(aws.Context, *autoscaling.DeleteLaunchConfigurationInput, ...request.Option) (*autoscaling.DeleteLaunchConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLaunchConfigurationRequest(*autoscaling.DeleteLaunchConfigurationInput) (*request.Request, *autoscaling.DeleteLaunchConfigurationOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLifecycleHook(*autoscaling.DeleteLifecycleHookInput) (*autoscaling.DeleteLifecycleHookOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLifecycleHookWithContext(aws.Context, *autoscaling.DeleteLifecycleHookInput, ...request.Option) (*autoscaling.DeleteLifecycleHookOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteLifecycleHookRequest(*autoscaling.DeleteLifecycleHookInput) (*request.Request, *autoscaling.DeleteLifecycleHookOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteNotificationConfiguration(*autoscaling.DeleteNotificationConfigurationInput) (*autoscaling.DeleteNotificationConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteNotificationConfigurationWithContext(aws.Context, *autoscaling.DeleteNotificationConfigurationInput, ...request.Option) (*autoscaling.DeleteNotificationConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteNotificationConfigurationRequest(*autoscaling.DeleteNotificationConfigurationInput) (*request.Request, *autoscaling.DeleteNotificationConfigurationOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeletePolicy(*autoscaling.DeletePolicyInput) (*autoscaling.DeletePolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeletePolicyWithContext(aws.Context, *autoscaling.DeletePolicyInput, ...request.Option) (*autoscaling.DeletePolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeletePolicyRequest(*autoscaling.DeletePolicyInput) (*request.Request, *autoscaling.DeletePolicyOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteScheduledAction(*autoscaling.DeleteScheduledActionInput) (*autoscaling.DeleteScheduledActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteScheduledActionWithContext(aws.Context, *autoscaling.DeleteScheduledActionInput, ...request.Option) (*autoscaling.DeleteScheduledActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteScheduledActionRequest(*autoscaling.DeleteScheduledActionInput) (*request.Request, *autoscaling.DeleteScheduledActionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteTags(*autoscaling.DeleteTagsInput) (*autoscaling.DeleteTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteTagsWithContext(aws.Context, *autoscaling.DeleteTagsInput, ...request.Option) (*autoscaling.DeleteTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DeleteTagsRequest(*autoscaling.DeleteTagsInput) (*request.Request, *autoscaling.DeleteTagsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAccountLimits(*autoscaling.DescribeAccountLimitsInput) (*autoscaling.DescribeAccountLimitsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAccountLimitsWithContext(aws.Context, *autoscaling.DescribeAccountLimitsInput, ...request.Option) (*autoscaling.DescribeAccountLimitsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAccountLimitsRequest(*autoscaling.DescribeAccountLimitsInput) (*request.Request, *autoscaling.DescribeAccountLimitsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAdjustmentTypes(*autoscaling.DescribeAdjustmentTypesInput) (*autoscaling.DescribeAdjustmentTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAdjustmentTypesWithContext(aws.Context, *autoscaling.DescribeAdjustmentTypesInput, ...request.Option) (*autoscaling.DescribeAdjustmentTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAdjustmentTypesRequest(*autoscaling.DescribeAdjustmentTypesInput) (*request.Request, *autoscaling.DescribeAdjustmentTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, ...request.Option) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsRequest(*autoscaling.DescribeAutoScalingGroupsInput) (*request.Request, *autoscaling.DescribeAutoScalingGroupsOutput) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsPages(*autoscaling.DescribeAutoScalingGroupsInput, func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool) error {
log.Fatal("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeAutoScalingGroupsPagesWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeAutoScalingInstances(*autoscaling.DescribeAutoScalingInstancesInput) (*autoscaling.DescribeAutoScalingInstancesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingInstancesWithContext(aws.Context, *autoscaling.DescribeAutoScalingInstancesInput, ...request.Option) (*autoscaling.DescribeAutoScalingInstancesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingInstancesRequest(*autoscaling.DescribeAutoScalingInstancesInput) (*request.Request, *autoscaling.DescribeAutoScalingInstancesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingInstancesPages(*autoscaling.DescribeAutoScalingInstancesInput, func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeAutoScalingInstancesPagesWithContext(aws.Context, *autoscaling.DescribeAutoScalingInstancesInput, func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeAutoScalingNotificationTypes(*autoscaling.DescribeAutoScalingNotificationTypesInput) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingNotificationTypesWithContext(aws.Context, *autoscaling.DescribeAutoScalingNotificationTypesInput, ...request.Option) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeAutoScalingNotificationTypesRequest(*autoscaling.DescribeAutoScalingNotificationTypesInput) (*request.Request, *autoscaling.DescribeAutoScalingNotificationTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurations(*autoscaling.DescribeLaunchConfigurationsInput) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsWithContext(aws.Context, *autoscaling.DescribeLaunchConfigurationsInput, ...request.Option) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsRequest(*autoscaling.DescribeLaunchConfigurationsInput) (*request.Request, *autoscaling.DescribeLaunchConfigurationsOutput) {
log.Fatal("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsPages(*autoscaling.DescribeLaunchConfigurationsInput, func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool) error {
log.Fatal("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeLaunchConfigurationsPagesWithContext(aws.Context, *autoscaling.DescribeLaunchConfigurationsInput, func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeLifecycleHookTypes(*autoscaling.DescribeLifecycleHookTypesInput) (*autoscaling.DescribeLifecycleHookTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLifecycleHookTypesWithContext(aws.Context, *autoscaling.DescribeLifecycleHookTypesInput, ...request.Option) (*autoscaling.DescribeLifecycleHookTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLifecycleHookTypesRequest(*autoscaling.DescribeLifecycleHookTypesInput) (*request.Request, *autoscaling.DescribeLifecycleHookTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLifecycleHooks(*autoscaling.DescribeLifecycleHooksInput) (*autoscaling.DescribeLifecycleHooksOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLifecycleHooksWithContext(aws.Context, *autoscaling.DescribeLifecycleHooksInput, ...request.Option) (*autoscaling.DescribeLifecycleHooksOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLifecycleHooksRequest(*autoscaling.DescribeLifecycleHooksInput) (*request.Request, *autoscaling.DescribeLifecycleHooksOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancerTargetGroups(*autoscaling.DescribeLoadBalancerTargetGroupsInput) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancerTargetGroupsWithContext(aws.Context, *autoscaling.DescribeLoadBalancerTargetGroupsInput, ...request.Option) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancerTargetGroupsRequest(*autoscaling.DescribeLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DescribeLoadBalancerTargetGroupsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancers(*autoscaling.DescribeLoadBalancersInput) (*autoscaling.DescribeLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancersWithContext(aws.Context, *autoscaling.DescribeLoadBalancersInput, ...request.Option) (*autoscaling.DescribeLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeLoadBalancersRequest(*autoscaling.DescribeLoadBalancersInput) (*request.Request, *autoscaling.DescribeLoadBalancersOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeMetricCollectionTypes(*autoscaling.DescribeMetricCollectionTypesInput) (*autoscaling.DescribeMetricCollectionTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeMetricCollectionTypesWithContext(aws.Context, *autoscaling.DescribeMetricCollectionTypesInput, ...request.Option) (*autoscaling.DescribeMetricCollectionTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeMetricCollectionTypesRequest(*autoscaling.DescribeMetricCollectionTypesInput) (*request.Request, *autoscaling.DescribeMetricCollectionTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeNotificationConfigurations(*autoscaling.DescribeNotificationConfigurationsInput) (*autoscaling.DescribeNotificationConfigurationsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeNotificationConfigurationsWithContext(aws.Context, *autoscaling.DescribeNotificationConfigurationsInput, ...request.Option) (*autoscaling.DescribeNotificationConfigurationsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeNotificationConfigurationsRequest(*autoscaling.DescribeNotificationConfigurationsInput) (*request.Request, *autoscaling.DescribeNotificationConfigurationsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeNotificationConfigurationsPages(*autoscaling.DescribeNotificationConfigurationsInput, func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeNotificationConfigurationsPagesWithContext(aws.Context, *autoscaling.DescribeNotificationConfigurationsInput, func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribePolicies(*autoscaling.DescribePoliciesInput) (*autoscaling.DescribePoliciesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribePoliciesWithContext(aws.Context, *autoscaling.DescribePoliciesInput, ...request.Option) (*autoscaling.DescribePoliciesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribePoliciesRequest(*autoscaling.DescribePoliciesInput) (*request.Request, *autoscaling.DescribePoliciesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribePoliciesPages(*autoscaling.DescribePoliciesInput, func(*autoscaling.DescribePoliciesOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribePoliciesPagesWithContext(aws.Context, *autoscaling.DescribePoliciesInput, func(*autoscaling.DescribePoliciesOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeScalingActivities(*autoscaling.DescribeScalingActivitiesInput) (*autoscaling.DescribeScalingActivitiesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScalingActivitiesWithContext(aws.Context, *autoscaling.DescribeScalingActivitiesInput, ...request.Option) (*autoscaling.DescribeScalingActivitiesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScalingActivitiesRequest(*autoscaling.DescribeScalingActivitiesInput) (*request.Request, *autoscaling.DescribeScalingActivitiesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScalingActivitiesPages(*autoscaling.DescribeScalingActivitiesInput, func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeScalingActivitiesPagesWithContext(aws.Context, *autoscaling.DescribeScalingActivitiesInput, func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeScalingProcessTypes(*autoscaling.DescribeScalingProcessTypesInput) (*autoscaling.DescribeScalingProcessTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScalingProcessTypesWithContext(aws.Context, *autoscaling.DescribeScalingProcessTypesInput, ...request.Option) (*autoscaling.DescribeScalingProcessTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScalingProcessTypesRequest(*autoscaling.DescribeScalingProcessTypesInput) (*request.Request, *autoscaling.DescribeScalingProcessTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScheduledActions(*autoscaling.DescribeScheduledActionsInput) (*autoscaling.DescribeScheduledActionsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScheduledActionsWithContext(aws.Context, *autoscaling.DescribeScheduledActionsInput, ...request.Option) (*autoscaling.DescribeScheduledActionsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScheduledActionsRequest(*autoscaling.DescribeScheduledActionsInput) (*request.Request, *autoscaling.DescribeScheduledActionsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeScheduledActionsPages(*autoscaling.DescribeScheduledActionsInput, func(*autoscaling.DescribeScheduledActionsOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeScheduledActionsPagesWithContext(aws.Context, *autoscaling.DescribeScheduledActionsInput, func(*autoscaling.DescribeScheduledActionsOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeTags(*autoscaling.DescribeTagsInput) (*autoscaling.DescribeTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeTagsWithContext(aws.Context, *autoscaling.DescribeTagsInput, ...request.Option) (*autoscaling.DescribeTagsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeTagsRequest(*autoscaling.DescribeTagsInput) (*request.Request, *autoscaling.DescribeTagsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeTagsPages(*autoscaling.DescribeTagsInput, func(*autoscaling.DescribeTagsOutput, bool) bool) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeTagsPagesWithContext(aws.Context, *autoscaling.DescribeTagsInput, func(*autoscaling.DescribeTagsOutput, bool) bool, ...request.Option) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) DescribeTerminationPolicyTypes(*autoscaling.DescribeTerminationPolicyTypesInput) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeTerminationPolicyTypesWithContext(aws.Context, *autoscaling.DescribeTerminationPolicyTypesInput, ...request.Option) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DescribeTerminationPolicyTypesRequest(*autoscaling.DescribeTerminationPolicyTypesInput) (*request.Request, *autoscaling.DescribeTerminationPolicyTypesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachInstances(*autoscaling.DetachInstancesInput) (*autoscaling.DetachInstancesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachInstancesWithContext(aws.Context, *autoscaling.DetachInstancesInput, ...request.Option) (*autoscaling.DetachInstancesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachInstancesRequest(*autoscaling.DetachInstancesInput) (*request.Request, *autoscaling.DetachInstancesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancerTargetGroups(*autoscaling.DetachLoadBalancerTargetGroupsInput) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancerTargetGroupsWithContext(aws.Context, *autoscaling.DetachLoadBalancerTargetGroupsInput, ...request.Option) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancerTargetGroupsRequest(*autoscaling.DetachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DetachLoadBalancerTargetGroupsOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancers(*autoscaling.DetachLoadBalancersInput) (*autoscaling.DetachLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancersWithContext(aws.Context, *autoscaling.DetachLoadBalancersInput, ...request.Option) (*autoscaling.DetachLoadBalancersOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DetachLoadBalancersRequest(*autoscaling.DetachLoadBalancersInput) (*request.Request, *autoscaling.DetachLoadBalancersOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DisableMetricsCollection(*autoscaling.DisableMetricsCollectionInput) (*autoscaling.DisableMetricsCollectionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DisableMetricsCollectionWithContext(aws.Context, *autoscaling.DisableMetricsCollectionInput, ...request.Option) (*autoscaling.DisableMetricsCollectionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) DisableMetricsCollectionRequest(*autoscaling.DisableMetricsCollectionInput) (*request.Request, *autoscaling.DisableMetricsCollectionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) EnableMetricsCollectionWithContext(aws.Context, *autoscaling.EnableMetricsCollectionInput, ...request.Option) (*autoscaling.EnableMetricsCollectionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) EnableMetricsCollectionRequest(*autoscaling.EnableMetricsCollectionInput) (*request.Request, *autoscaling.EnableMetricsCollectionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) EnterStandby(*autoscaling.EnterStandbyInput) (*autoscaling.EnterStandbyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) EnterStandbyWithContext(aws.Context, *autoscaling.EnterStandbyInput, ...request.Option) (*autoscaling.EnterStandbyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) EnterStandbyRequest(*autoscaling.EnterStandbyInput) (*request.Request, *autoscaling.EnterStandbyOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExecutePolicy(*autoscaling.ExecutePolicyInput) (*autoscaling.ExecutePolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExecutePolicyWithContext(aws.Context, *autoscaling.ExecutePolicyInput, ...request.Option) (*autoscaling.ExecutePolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExecutePolicyRequest(*autoscaling.ExecutePolicyInput) (*request.Request, *autoscaling.ExecutePolicyOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExitStandby(*autoscaling.ExitStandbyInput) (*autoscaling.ExitStandbyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExitStandbyWithContext(aws.Context, *autoscaling.ExitStandbyInput, ...request.Option) (*autoscaling.ExitStandbyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ExitStandbyRequest(*autoscaling.ExitStandbyInput) (*request.Request, *autoscaling.ExitStandbyOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutLifecycleHook(*autoscaling.PutLifecycleHookInput) (*autoscaling.PutLifecycleHookOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutLifecycleHookWithContext(aws.Context, *autoscaling.PutLifecycleHookInput, ...request.Option) (*autoscaling.PutLifecycleHookOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutLifecycleHookRequest(*autoscaling.PutLifecycleHookInput) (*request.Request, *autoscaling.PutLifecycleHookOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutNotificationConfiguration(*autoscaling.PutNotificationConfigurationInput) (*autoscaling.PutNotificationConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutNotificationConfigurationWithContext(aws.Context, *autoscaling.PutNotificationConfigurationInput, ...request.Option) (*autoscaling.PutNotificationConfigurationOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutNotificationConfigurationRequest(*autoscaling.PutNotificationConfigurationInput) (*request.Request, *autoscaling.PutNotificationConfigurationOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScalingPolicy(*autoscaling.PutScalingPolicyInput) (*autoscaling.PutScalingPolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScalingPolicyWithContext(aws.Context, *autoscaling.PutScalingPolicyInput, ...request.Option) (*autoscaling.PutScalingPolicyOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScalingPolicyRequest(*autoscaling.PutScalingPolicyInput) (*request.Request, *autoscaling.PutScalingPolicyOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScheduledUpdateGroupAction(*autoscaling.PutScheduledUpdateGroupActionInput) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScheduledUpdateGroupActionWithContext(aws.Context, *autoscaling.PutScheduledUpdateGroupActionInput, ...request.Option) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) PutScheduledUpdateGroupActionRequest(*autoscaling.PutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.PutScheduledUpdateGroupActionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) RecordLifecycleActionHeartbeat(*autoscaling.RecordLifecycleActionHeartbeatInput) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) RecordLifecycleActionHeartbeatWithContext(aws.Context, *autoscaling.RecordLifecycleActionHeartbeatInput, ...request.Option) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) RecordLifecycleActionHeartbeatRequest(*autoscaling.RecordLifecycleActionHeartbeatInput) (*request.Request, *autoscaling.RecordLifecycleActionHeartbeatOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ResumeProcesses(*autoscaling.ScalingProcessQuery) (*autoscaling.ResumeProcessesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ResumeProcessesWithContext(aws.Context, *autoscaling.ScalingProcessQuery, ...request.Option) (*autoscaling.ResumeProcessesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) ResumeProcessesRequest(*autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.ResumeProcessesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetDesiredCapacity(*autoscaling.SetDesiredCapacityInput) (*autoscaling.SetDesiredCapacityOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetDesiredCapacityWithContext(aws.Context, *autoscaling.SetDesiredCapacityInput, ...request.Option) (*autoscaling.SetDesiredCapacityOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetDesiredCapacityRequest(*autoscaling.SetDesiredCapacityInput) (*request.Request, *autoscaling.SetDesiredCapacityOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceHealth(*autoscaling.SetInstanceHealthInput) (*autoscaling.SetInstanceHealthOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceHealthWithContext(aws.Context, *autoscaling.SetInstanceHealthInput, ...request.Option) (*autoscaling.SetInstanceHealthOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceHealthRequest(*autoscaling.SetInstanceHealthInput) (*request.Request, *autoscaling.SetInstanceHealthOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceProtection(*autoscaling.SetInstanceProtectionInput) (*autoscaling.SetInstanceProtectionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceProtectionWithContext(aws.Context, *autoscaling.SetInstanceProtectionInput, ...request.Option) (*autoscaling.SetInstanceProtectionOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SetInstanceProtectionRequest(*autoscaling.SetInstanceProtectionInput) (*request.Request, *autoscaling.SetInstanceProtectionOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SuspendProcesses(*autoscaling.ScalingProcessQuery) (*autoscaling.SuspendProcessesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SuspendProcessesWithContext(aws.Context, *autoscaling.ScalingProcessQuery, ...request.Option) (*autoscaling.SuspendProcessesOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) SuspendProcessesRequest(*autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.SuspendProcessesOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) TerminateInstanceInAutoScalingGroupWithContext(aws.Context, *autoscaling.TerminateInstanceInAutoScalingGroupInput, ...request.Option) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) TerminateInstanceInAutoScalingGroupRequest(*autoscaling.TerminateInstanceInAutoScalingGroupInput) (*request.Request, *autoscaling.TerminateInstanceInAutoScalingGroupOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) UpdateAutoScalingGroup(*autoscaling.UpdateAutoScalingGroupInput) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) UpdateAutoScalingGroupWithContext(aws.Context, *autoscaling.UpdateAutoScalingGroupInput, ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) UpdateAutoScalingGroupRequest(*autoscaling.UpdateAutoScalingGroupInput) (*request.Request, *autoscaling.UpdateAutoScalingGroupOutput) {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil, nil
}
func (m *MockAutoscaling) WaitUntilGroupExists(*autoscaling.DescribeAutoScalingGroupsInput) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) WaitUntilGroupExistsWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, ...request.WaiterOption) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) WaitUntilGroupInService(*autoscaling.DescribeAutoScalingGroupsInput) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) WaitUntilGroupInServiceWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, ...request.WaiterOption) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) WaitUntilGroupNotExists(*autoscaling.DescribeAutoScalingGroupsInput) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}
func (m *MockAutoscaling) WaitUntilGroupNotExistsWithContext(aws.Context, *autoscaling.DescribeAutoScalingGroupsInput, ...request.WaiterOption) error {
log.Fatal("Not implemented")
glog.Fatalf("Not implemented")
return nil
}

2
cloudmock/aws/mockec2/BUILD.bazel
View File

@ -6,6 +6,7 @@ go_library(
"address.go",
"api.go",
"convenience.go",
"dhcpoptions.go",
"images.go",
"internetgateways.go",
"keypairs.go",
@ -20,6 +21,7 @@ go_library(
importpath = "k8s.io/kops/cloudmock/aws/mockec2",
visibility = ["//visibility:public"],
deps = [
"//pkg/pki:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/aws:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/aws/request:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/ec2:go_default_library",

34
cloudmock/aws/mockec2/api.go
View File

@ -17,26 +17,32 @@ limitations under the License.
package mockec2
import (
"fmt"
"sync"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
)
type MockEC2 struct {
mutex sync.Mutex
addressNumber int
Addresses []*ec2.Address
RouteTables []*ec2.RouteTable
RouteTables map[string]*ec2.RouteTable
DhcpOptions map[string]*ec2.DhcpOptions
Images []*ec2.Image
securityGroupNumber int
SecurityGroups []*ec2.SecurityGroup
SecurityGroups map[string]*ec2.SecurityGroup
subnetNumber int
subnets map[string]*subnetInfo
volumeNumber int
Volumes []*ec2.Volume
Volumes map[string]*ec2.Volume
KeyPairs []*ec2.KeyPairInfo
@ -47,6 +53,26 @@ type MockEC2 struct {
internetGatewayNumber int
InternetGateways map[string]*internetGatewayInfo
ids map[string]*idAllocator
}
var _ ec2iface.EC2API = &MockEC2{}
type idAllocator struct {
NextId int
}
func (m *MockEC2) allocateId(prefix string) string {
ids := m.ids[prefix]
if ids == nil {
if m.ids == nil {
m.ids = make(map[string]*idAllocator)
}
ids = &idAllocator{NextId: 1}
m.ids[prefix] = ids
}
id := ids.NextId
ids.NextId++
return fmt.Sprintf("%s-%d", prefix, id)
}

175
cloudmock/aws/mockec2/dhcpoptions.go Normal file
View File

@ -0,0 +1,175 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockec2
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/golang/glog"
)
func (m *MockEC2) DescribeDhcpOptions(request *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
glog.Infof("DescribeDhcpOptions: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun not implemented")
}
if request.DhcpOptionsIds != nil {
glog.Fatalf("DhcpOptionsIds not implemented")
}
response := &ec2.DescribeDhcpOptionsOutput{}
for id, dhcpOptions := range m.DhcpOptions {
allFiltersMatch := true
for _, filter := range request.Filters {
match := false
switch *filter.Name {
// case "vpc-id":
// if *subnet.main.VpcId == *filter.Values[0] {
// match = true
// }
default:
if strings.HasPrefix(*filter.Name, "tag:") {
match = m.hasTag(ec2.ResourceTypeDhcpOptions, *dhcpOptions.DhcpOptionsId, filter)
} else {
return nil, fmt.Errorf("unknown filter name: %q", *filter.Name)
}
}
if !match {
allFiltersMatch = false
break
}
}
if !allFiltersMatch {
continue
}
copy := *dhcpOptions
copy.Tags = m.getTags(ec2.ResourceTypeDhcpOptions, id)
response.DhcpOptions = append(response.DhcpOptions, &copy)
}
return response, nil
}
func (m *MockEC2) DescribeDhcpOptionsWithContext(aws.Context, *ec2.DescribeDhcpOptionsInput, ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DescribeDhcpOptionsRequest(*ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateDhcpOptions(request *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("AssociateDhcpOptions: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
dopt := m.DhcpOptions[*request.DhcpOptionsId]
if dopt == nil {
return nil, fmt.Errorf("DhcpOptions not found")
}
vpc := m.Vpcs[*request.VpcId]
if vpc == nil {
return nil, fmt.Errorf("vpc not found")
}
vpc.main.DhcpOptionsId = dopt.DhcpOptionsId
response := &ec2.AssociateDhcpOptionsOutput{}
return response, nil
}
func (m *MockEC2) AssociateDhcpOptionsWithContext(aws.Context, *ec2.AssociateDhcpOptionsInput, ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateDhcpOptionsRequest(*ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateDhcpOptions(request *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateDhcpOptions: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
n := len(m.DhcpOptions) + 1
dhcpOptions := &ec2.DhcpOptions{
DhcpOptionsId: s(fmt.Sprintf("dopt-%d", n)),
}
for _, o := range request.DhcpConfigurations {
c := &ec2.DhcpConfiguration{
Key: o.Key,
}
for _, v := range o.Values {
c.Values = append(c.Values, &ec2.AttributeValue{
Value: v,
})
}
dhcpOptions.DhcpConfigurations = append(dhcpOptions.DhcpConfigurations, c)
}
if m.DhcpOptions == nil {
m.DhcpOptions = make(map[string]*ec2.DhcpOptions)
}
m.DhcpOptions[*dhcpOptions.DhcpOptionsId] = dhcpOptions
copy := *dhcpOptions
copy.Tags = m.getTags(ec2.ResourceTypeDhcpOptions, *dhcpOptions.DhcpOptionsId)
return &ec2.CreateDhcpOptionsOutput{DhcpOptions: &copy}, nil
}
func (m *MockEC2) CreateDhcpOptionsWithContext(aws.Context, *ec2.CreateDhcpOptionsInput, ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateDhcpOptionsRequest(*ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptions(*ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptionsWithContext(aws.Context, *ec2.DeleteDhcpOptionsInput, ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptionsRequest(*ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}

7
cloudmock/aws/mockec2/keypairs.go
View File

@ -23,6 +23,8 @@ import (
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/golang/glog"
"k8s.io/kops/pkg/pki"
)
func (m *MockEC2) DescribeKeyPairsRequest(*ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) {
@ -42,7 +44,10 @@ func (m *MockEC2) ImportKeyPairWithContext(aws.Context, *ec2.ImportKeyPairInput,
func (m *MockEC2) ImportKeyPair(request *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) {
glog.Infof("ImportKeyPair: %v", request)
fp := "12345" // TODO: calculate fingerprint
fp, err := pki.ComputeAWSKeyFingerprint(string(request.PublicKeyMaterial))
if err != nil {
return nil, err
}
kp := &ec2.KeyPairInfo{
KeyFingerprint: aws.String(fp),

148
cloudmock/aws/mockec2/routetable.go
View File

@ -17,12 +17,29 @@ limitations under the License.
package mockec2
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/golang/glog"
)
func (m *MockEC2) AddRouteTable(rt *ec2.RouteTable) {
m.mutex.Lock()
defer m.mutex.Unlock()
if m.RouteTables == nil {
m.RouteTables = make(map[string]*ec2.RouteTable)
}
for _, tag := range rt.Tags {
m.addTag(*rt.RouteTableId, tag)
}
rt.Tags = nil
m.RouteTables[*rt.RouteTableId] = rt
}
func (m *MockEC2) DescribeRouteTablesRequest(*ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) {
panic("Not implemented")
return nil, nil
@ -34,19 +51,138 @@ func (m *MockEC2) DescribeRouteTablesWithContext(aws.Context, *ec2.DescribeRoute
}
func (m *MockEC2) DescribeRouteTables(request *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) {
if request.Filters != nil {
glog.Fatalf("filters not implemented: %v", request.Filters)
}
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("DescribeRouteTables: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun not implemented")
}
if request.RouteTableIds != nil {
glog.Fatalf("RouteTableIds not implemented")
if len(request.RouteTableIds) != 0 {
request.Filters = append(request.Filters, &ec2.Filter{Name: s("route-table-id"), Values: request.RouteTableIds})
}
response := &ec2.DescribeRouteTablesOutput{}
for _, rt := range m.RouteTables {
response.RouteTables = append(response.RouteTables, rt)
allFiltersMatch := true
for _, filter := range request.Filters {
match := false
switch *filter.Name {
case "route-table-id":
for _, v := range filter.Values {
if *rt.RouteTableId == *v {
match = true
}
}
case "association.subnet-id":
for _, a := range rt.Associations {
for _, v := range filter.Values {
if aws.StringValue(a.SubnetId) == *v {
match = true
}
}
}
default:
if strings.HasPrefix(*filter.Name, "tag:") {
match = m.hasTag(ec2.ResourceTypeRouteTable, *rt.RouteTableId, filter)
} else {
return nil, fmt.Errorf("unknown filter name: %q", *filter.Name)
}
}
if !match {
allFiltersMatch = false
break
}
}
if !allFiltersMatch {
continue
}
copy := *rt
copy.Tags = m.getTags(ec2.ResourceTypeRouteTable, *rt.RouteTableId)
response.RouteTables = append(response.RouteTables, &copy)
}
return response, nil
}
func (m *MockEC2) CreateRouteTable(request *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateRouteTable: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
n := len(m.RouteTables) + 1
rt := &ec2.RouteTable{
RouteTableId: s(fmt.Sprintf("rtb-%d", n)),
VpcId: request.VpcId,
}
if m.RouteTables == nil {
m.RouteTables = make(map[string]*ec2.RouteTable)
}
m.RouteTables[*rt.RouteTableId] = rt
copy := *rt
response := &ec2.CreateRouteTableOutput{
RouteTable: &copy,
}
return response, nil
}
func (m *MockEC2) CreateRouteTableWithContext(aws.Context, *ec2.CreateRouteTableInput, ...request.Option) (*ec2.CreateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteTableRequest(*ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRoute(request *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateRoute: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
rt := m.RouteTables[aws.StringValue(request.RouteTableId)]
if rt == nil {
return nil, fmt.Errorf("RouteTable not found")
}
r := &ec2.Route{
DestinationCidrBlock: request.DestinationCidrBlock,
DestinationIpv6CidrBlock: request.DestinationIpv6CidrBlock,
EgressOnlyInternetGatewayId: request.EgressOnlyInternetGatewayId,
GatewayId: request.GatewayId,
InstanceId: request.InstanceId,
NatGatewayId: request.NatGatewayId,
NetworkInterfaceId: request.NetworkInterfaceId,
VpcPeeringConnectionId: request.VpcPeeringConnectionId,
}
rt.Routes = append(rt.Routes, r)
return &ec2.CreateRouteOutput{Return: aws.Bool(true)}, nil
}
func (m *MockEC2) CreateRouteWithContext(aws.Context, *ec2.CreateRouteInput, ...request.Option) (*ec2.CreateRouteOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteRequest(*ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) {
panic("Not implemented")
return nil, nil
}

124
cloudmock/aws/mockec2/securitygroups.go
View File

@ -37,6 +37,9 @@ func (m *MockEC2) CreateSecurityGroupWithContext(aws.Context, *ec2.CreateSecurit
}
func (m *MockEC2) CreateSecurityGroup(request *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateSecurityGroup: %v", request)
m.securityGroupNumber++
@ -48,7 +51,11 @@ func (m *MockEC2) CreateSecurityGroup(request *ec2.CreateSecurityGroupInput) (*e
VpcId: request.VpcId,
Description: request.Description,
}
m.SecurityGroups = append(m.SecurityGroups, sg)
if m.SecurityGroups == nil {
m.SecurityGroups = make(map[string]*ec2.SecurityGroup)
}
m.SecurityGroups[*sg.GroupId] = sg
response := &ec2.CreateSecurityGroupOutput{
GroupId: sg.GroupId,
}
@ -91,6 +98,10 @@ func (m *MockEC2) DescribeSecurityGroupsWithContext(aws.Context, *ec2.DescribeSe
func (m *MockEC2) DescribeSecurityGroups(request *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) {
glog.Infof("DescribeSecurityGroups: %v", request)
if len(request.GroupIds) != 0 {
request.Filters = append(request.Filters, &ec2.Filter{Name: s("group-id"), Values: request.GroupIds})
}
var groups []*ec2.SecurityGroup
for _, sg := range m.SecurityGroups {
@ -111,6 +122,12 @@ func (m *MockEC2) DescribeSecurityGroups(request *ec2.DescribeSecurityGroupsInpu
match = true
}
}
case "group-id":
for _, v := range filter.Values {
if sg.GroupId != nil && *sg.GroupId == *v {
match = true
}
}
default:
if strings.HasPrefix(*filter.Name, "tag:") {
@ -186,9 +203,54 @@ func (m *MockEC2) AuthorizeSecurityGroupEgressWithContext(aws.Context, *ec2.Auth
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AuthorizeSecurityGroupEgress(*ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
panic("Not implemented")
return nil, nil
func (m *MockEC2) AuthorizeSecurityGroupEgress(request *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("AuthorizeSecurityGroupEgress: %v", request)
if aws.StringValue(request.GroupId) == "" {
return nil, fmt.Errorf("GroupId not specified")
}
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
sg := m.SecurityGroups[*request.GroupId]
if sg == nil {
return nil, fmt.Errorf("sg not found")
}
if request.CidrIp != nil {
if request.SourceSecurityGroupName != nil {
glog.Fatalf("SourceSecurityGroupName not implemented")
}
if request.SourceSecurityGroupOwnerId != nil {
glog.Fatalf("SourceSecurityGroupOwnerId not implemented")
}
p := &ec2.IpPermission{
FromPort: request.FromPort,
ToPort: request.ToPort,
IpProtocol: request.IpProtocol,
}
if request.CidrIp != nil {
p.IpRanges = append(p.IpRanges, &ec2.IpRange{CidrIp: request.CidrIp})
}
sg.IpPermissionsEgress = append(sg.IpPermissionsEgress, p)
}
for _, p := range request.IpPermissions {
sg.IpPermissionsEgress = append(sg.IpPermissionsEgress, p)
}
// TODO: We need to fold permissions
response := &ec2.AuthorizeSecurityGroupEgressOutput{}
return response, nil
}
func (m *MockEC2) AuthorizeSecurityGroupIngressRequest(*ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) {
panic("Not implemented")
@ -198,7 +260,55 @@ func (m *MockEC2) AuthorizeSecurityGroupIngressWithContext(aws.Context, *ec2.Aut
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AuthorizeSecurityGroupIngress(*ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
panic("Not implemented")
return nil, nil
func (m *MockEC2) AuthorizeSecurityGroupIngress(request *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("AuthorizeSecurityGroupIngress: %v", request)
if aws.StringValue(request.GroupId) == "" {
return nil, fmt.Errorf("GroupId not specified")
}
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
if request.GroupName != nil {
glog.Fatalf("GroupName not implemented")
}
sg := m.SecurityGroups[*request.GroupId]
if sg == nil {
return nil, fmt.Errorf("sg not found")
}
if request.CidrIp != nil {
if request.SourceSecurityGroupName != nil {
glog.Fatalf("SourceSecurityGroupName not implemented")
}
if request.SourceSecurityGroupOwnerId != nil {
glog.Fatalf("SourceSecurityGroupOwnerId not implemented")
}
p := &ec2.IpPermission{
FromPort: request.FromPort,
ToPort: request.ToPort,
IpProtocol: request.IpProtocol,
}
if request.CidrIp != nil {
p.IpRanges = append(p.IpRanges, &ec2.IpRange{CidrIp: request.CidrIp})
}
sg.IpPermissions = append(sg.IpPermissions, p)
}
for _, p := range request.IpPermissions {
sg.IpPermissions = append(sg.IpPermissions, p)
}
// TODO: We need to fold permissions
response := &ec2.AuthorizeSecurityGroupIngressOutput{}
return response, nil
}

66
cloudmock/aws/mockec2/subnets.go
View File

@ -60,6 +60,9 @@ func (m *MockEC2) CreateSubnetWithContext(aws.Context, *ec2.CreateSubnetInput, .
}
func (m *MockEC2) CreateSubnet(request *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateSubnet: %v", request)
m.subnetNumber++
@ -98,6 +101,10 @@ func (m *MockEC2) DescribeSubnetsWithContext(aws.Context, *ec2.DescribeSubnetsIn
func (m *MockEC2) DescribeSubnets(request *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) {
glog.Infof("DescribeSubnets: %v", request)
if len(request.SubnetIds) != 0 {
request.Filters = append(request.Filters, &ec2.Filter{Name: s("subnet-id"), Values: request.SubnetIds})
}
var subnets []*ec2.Subnet
for id, subnet := range m.subnets {
@ -109,6 +116,12 @@ func (m *MockEC2) DescribeSubnets(request *ec2.DescribeSubnetsInput) (*ec2.Descr
if *subnet.main.VpcId == *filter.Values[0] {
match = true
}
case "subnet-id":
for _, v := range filter.Values {
if *subnet.main.SubnetId == *v {
match = true
}
}
default:
if strings.HasPrefix(*filter.Name, "tag:") {
match = m.hasTag(ec2.ResourceTypeSubnet, *subnet.main.SubnetId, filter)
@ -138,3 +151,56 @@ func (m *MockEC2) DescribeSubnets(request *ec2.DescribeSubnetsInput) (*ec2.Descr
return response, nil
}
func (m *MockEC2) AssociateRouteTable(request *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("AuthorizeSecurityGroupIngress: %v", request)
if aws.StringValue(request.SubnetId) == "" {
return nil, fmt.Errorf("SubnetId not specified")
}
if aws.StringValue(request.RouteTableId) == "" {
return nil, fmt.Errorf("RouteTableId not specified")
}
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
subnet := m.subnets[*request.SubnetId]
if subnet == nil {
return nil, fmt.Errorf("Subnet not found")
}
rt := m.RouteTables[*request.RouteTableId]
if rt == nil {
return nil, fmt.Errorf("RouteTable not found")
}
associationID := m.allocateId("rta-")
rt.Associations = append(rt.Associations, &ec2.RouteTableAssociation{
RouteTableId: rt.RouteTableId,
SubnetId: subnet.main.SubnetId,
RouteTableAssociationId: &associationID,
})
// TODO: More fields
// // Indicates whether this is the main route table.
// Main *bool `locationName:"main" type:"boolean"`
// TODO: We need to fold permissions
response := &ec2.AssociateRouteTableOutput{
AssociationId: &associationID,
}
return response, nil
}
func (m *MockEC2) AssociateRouteTableWithContext(aws.Context, *ec2.AssociateRouteTableInput, ...request.Option) (*ec2.AssociateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateRouteTableRequest(*ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) {
panic("Not implemented")
return nil, nil
}

52
cloudmock/aws/mockec2/tags.go
View File

@ -42,35 +42,43 @@ func (m *MockEC2) CreateTags(request *ec2.CreateTagsInput) (*ec2.CreateTagsOutpu
for _, v := range request.Resources {
resourceId := *v
resourceType := ""
if strings.HasPrefix(resourceId, "subnet-") {
resourceType = ec2.ResourceTypeSubnet
} else if strings.HasPrefix(resourceId, "vpc-") {
resourceType = ec2.ResourceTypeVpc
} else if strings.HasPrefix(resourceId, "sg-") {
resourceType = ec2.ResourceTypeSecurityGroup
} else if strings.HasPrefix(resourceId, "vol-") {
resourceType = ec2.ResourceTypeVolume
} else if strings.HasPrefix(resourceId, "igw-") {
resourceType = ec2.ResourceTypeInternetGateway
} else {
glog.Fatalf("Unknown resource-type in create tags: %v", resourceId)
}
for _, tag := range request.Tags {
t := &ec2.TagDescription{
Key: tag.Key,
Value: tag.Value,
ResourceId: s(resourceId),
ResourceType: s(resourceType),
}
m.Tags = append(m.Tags, t)
m.addTag(resourceId, tag)
}
}
response := &ec2.CreateTagsOutput{}
return response, nil
}
func (m *MockEC2) addTag(resourceId string, tag *ec2.Tag) {
resourceType := ""
if strings.HasPrefix(resourceId, "subnet-") {
resourceType = ec2.ResourceTypeSubnet
} else if strings.HasPrefix(resourceId, "vpc-") {
resourceType = ec2.ResourceTypeVpc
} else if strings.HasPrefix(resourceId, "sg-") {
resourceType = ec2.ResourceTypeSecurityGroup
} else if strings.HasPrefix(resourceId, "vol-") {
resourceType = ec2.ResourceTypeVolume
} else if strings.HasPrefix(resourceId, "igw-") {
resourceType = ec2.ResourceTypeInternetGateway
} else if strings.HasPrefix(resourceId, "dopt-") {
resourceType = ec2.ResourceTypeDhcpOptions
} else if strings.HasPrefix(resourceId, "rtb-") {
resourceType = ec2.ResourceTypeRouteTable
} else {
glog.Fatalf("Unknown resource-type in create tags: %v", resourceId)
}
t := &ec2.TagDescription{
Key: tag.Key,
Value: tag.Value,
ResourceId: s(resourceId),
ResourceType: s(resourceType),
}
m.Tags = append(m.Tags, t)
}
func (m *MockEC2) DescribeTagsRequest(*ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) {
panic("Not implemented")
return nil, nil

117
cloudmock/aws/mockec2/unimplemented.go
View File

@ -74,19 +74,6 @@ func (m *MockEC2) AssignIpv6AddressesRequest(*ec2.AssignIpv6AddressesInput) (*re
return nil, nil
}
func (m *MockEC2) AssociateDhcpOptions(*ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateDhcpOptionsWithContext(aws.Context, *ec2.AssociateDhcpOptionsInput, ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateDhcpOptionsRequest(*ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateIamInstanceProfile(*ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) {
panic("Not implemented")
return nil, nil
@ -100,19 +87,6 @@ func (m *MockEC2) AssociateIamInstanceProfileRequest(*ec2.AssociateIamInstancePr
return nil, nil
}
func (m *MockEC2) AssociateRouteTable(*ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateRouteTableWithContext(aws.Context, *ec2.AssociateRouteTableInput, ...request.Option) (*ec2.AssociateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateRouteTableRequest(*ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) AssociateSubnetCidrBlock(*ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) {
panic("Not implemented")
return nil, nil
@ -360,19 +334,6 @@ func (m *MockEC2) CreateDefaultVpcRequest(*ec2.CreateDefaultVpcInput) (*request.
return nil, nil
}
func (m *MockEC2) CreateDhcpOptions(*ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateDhcpOptionsWithContext(aws.Context, *ec2.CreateDhcpOptionsInput, ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateDhcpOptionsRequest(*ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateEgressOnlyInternetGateway(*ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) {
panic("Not implemented")
return nil, nil
@ -529,32 +490,6 @@ func (m *MockEC2) CreateReservedInstancesListingRequest(*ec2.CreateReservedInsta
return nil, nil
}
func (m *MockEC2) CreateRoute(*ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteWithContext(aws.Context, *ec2.CreateRouteInput, ...request.Option) (*ec2.CreateRouteOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteRequest(*ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteTable(*ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteTableWithContext(aws.Context, *ec2.CreateRouteTableInput, ...request.Option) (*ec2.CreateRouteTableOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateRouteTableRequest(*ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateSnapshot(*ec2.CreateSnapshotInput) (*ec2.Snapshot, error) {
panic("Not implemented")
return nil, nil
@ -581,19 +516,6 @@ func (m *MockEC2) CreateSpotDatafeedSubscriptionRequest(*ec2.CreateSpotDatafeedS
return nil, nil
}
func (m *MockEC2) CreateVolume(*ec2.CreateVolumeInput) (*ec2.Volume, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateVolumeWithContext(aws.Context, *ec2.CreateVolumeInput, ...request.Option) (*ec2.Volume, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateVolumeRequest(*ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateVpcEndpoint(*ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) {
panic("Not implemented")
return nil, nil
@ -672,19 +594,6 @@ func (m *MockEC2) DeleteCustomerGatewayRequest(*ec2.DeleteCustomerGatewayInput)
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptions(*ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptionsWithContext(aws.Context, *ec2.DeleteDhcpOptionsInput, ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteDhcpOptionsRequest(*ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DeleteEgressOnlyInternetGateway(*ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) {
panic("Not implemented")
return nil, nil
@ -1088,19 +997,6 @@ func (m *MockEC2) DescribeCustomerGatewaysRequest(*ec2.DescribeCustomerGatewaysI
return nil, nil
}
func (m *MockEC2) DescribeDhcpOptions(*ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DescribeDhcpOptionsWithContext(aws.Context, *ec2.DescribeDhcpOptionsInput, ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DescribeDhcpOptionsRequest(*ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DescribeEgressOnlyInternetGateways(*ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) {
panic("Not implemented")
return nil, nil
@ -2278,19 +2174,6 @@ func (m *MockEC2) ModifyVolumeAttributeRequest(*ec2.ModifyVolumeAttributeInput)
return nil, nil
}
func (m *MockEC2) ModifyVpcAttribute(*ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) ModifyVpcAttributeWithContext(aws.Context, *ec2.ModifyVpcAttributeInput, ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) ModifyVpcAttributeRequest(*ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) ModifyVpcEndpoint(*ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) {
panic("Not implemented")
return nil, nil

62
cloudmock/aws/mockec2/volumes.go
View File

@ -26,6 +26,64 @@ import (
"github.com/golang/glog"
)
func (m *MockEC2) CreateVolume(request *ec2.CreateVolumeInput) (*ec2.Volume, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateVolume: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
n := len(m.Volumes) + 1
volume := &ec2.Volume{
VolumeId: s(fmt.Sprintf("vol-%d", n)),
AvailabilityZone: request.AvailabilityZone,
Encrypted: request.Encrypted,
Iops: request.Iops,
KmsKeyId: request.KmsKeyId,
Size: request.Size,
SnapshotId: request.SnapshotId,
VolumeType: request.VolumeType,
}
for _, tags := range request.TagSpecifications {
for _, tag := range tags.Tags {
m.addTag(*volume.VolumeId, tag)
}
}
if m.Volumes == nil {
m.Volumes = make(map[string]*ec2.Volume)
}
m.Volumes[*volume.VolumeId] = volume
copy := *volume
copy.Tags = m.getTags(ec2.ResourceTypeVolume, *volume.VolumeId)
// TODO: a few fields
// // Information about the volume attachments.
// Attachments []*VolumeAttachment `locationName:"attachmentSet" locationNameList:"item" type:"list"`
// // The time stamp when volume creation was initiated.
// CreateTime *time.Time `locationName:"createTime" type:"timestamp" timestampFormat:"iso8601"`
// // The volume state.
// State *string `locationName:"status" type:"string" enum:"VolumeState"`
return &copy, nil
}
func (m *MockEC2) CreateVolumeWithContext(aws.Context, *ec2.CreateVolumeInput, ...request.Option) (*ec2.Volume, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) CreateVolumeRequest(*ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) DescribeVolumeAttributeRequest(*ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) {
panic("MockEC2 DescribeVolumeAttributeRequest not implemented")
return nil, nil
@ -69,6 +127,10 @@ func (m *MockEC2) DescribeVolumesWithContext(aws.Context, *ec2.DescribeVolumesIn
func (m *MockEC2) DescribeVolumes(request *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) {
glog.Infof("DescribeVolumes: %v", request)
if request.VolumeIds != nil {
glog.Fatalf("VolumeIds")
}
var volumes []*ec2.Volume
for _, volume := range m.Volumes {

36
cloudmock/aws/mockec2/vpcs.go
View File

@ -54,6 +54,10 @@ func (m *MockEC2) CreateVpcWithContext(aws.Context, *ec2.CreateVpcInput, ...requ
func (m *MockEC2) CreateVpc(request *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) {
glog.Infof("CreateVpc: %v", request)
if request.DryRun != nil {
glog.Fatalf("DryRun")
}
m.vpcNumber++
n := m.vpcNumber
@ -158,3 +162,35 @@ func (m *MockEC2) DescribeVpcAttribute(request *ec2.DescribeVpcAttributeInput) (
return response, nil
}
func (m *MockEC2) ModifyVpcAttribute(request *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) {
glog.Infof("ModifyVpcAttribute: %v", request)
m.mutex.Lock()
defer m.mutex.Unlock()
vpc := m.Vpcs[*request.VpcId]
if vpc == nil {
return nil, fmt.Errorf("not found")
}
if request.EnableDnsHostnames != nil {
vpc.attributes.EnableDnsHostnames = request.EnableDnsHostnames
}
if request.EnableDnsSupport != nil {
vpc.attributes.EnableDnsSupport = request.EnableDnsSupport
}
response := &ec2.ModifyVpcAttributeOutput{}
return response, nil
}
func (m *MockEC2) ModifyVpcAttributeWithContext(aws.Context, *ec2.ModifyVpcAttributeInput, ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockEC2) ModifyVpcAttributeRequest(*ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) {
panic("Not implemented")
return nil, nil
}

22
cloudmock/aws/mockiam/BUILD.bazel Normal file
View File

@ -0,0 +1,22 @@
load("@io_bazel_rules_go//go:def.bzl", "go_library")
go_library(
name = "go_default_library",
srcs = [
"api.go",
"iaminstanceprofile.go",
"iamrole.go",
"iamrolepolicy.go",
"unimplemented.go",
],
importpath = "k8s.io/kops/cloudmock/aws/mockiam",
visibility = ["//visibility:public"],
deps = [
"//vendor/github.com/aws/aws-sdk-go/aws:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/aws/awserr:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/aws/request:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/iam:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/iam/iamiface:go_default_library",
"//vendor/github.com/golang/glog:go_default_library",
],
)

39
cloudmock/aws/mockiam/api.go Normal file
View File

@ -0,0 +1,39 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockiam
import (
"fmt"
"math/rand"
"sync"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/aws/aws-sdk-go/service/iam/iamiface"
)
type MockIAM struct {
mutex sync.Mutex
InstanceProfiles map[string]*iam.InstanceProfile
Roles map[string]*iam.Role
RolePolicies []*rolePolicy
}
var _ iamiface.IAMAPI = &MockIAM{}
func (m *MockIAM) createID() string {
return "AID" + fmt.Sprintf("%x", rand.Int63())
}

116
cloudmock/aws/mockiam/iaminstanceprofile.go Normal file
View File

@ -0,0 +1,116 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockiam
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/golang/glog"
)
func (m *MockIAM) GetInstanceProfile(request *iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error) {
ip := m.InstanceProfiles[aws.StringValue(request.InstanceProfileName)]
if ip == nil {
return nil, awserr.New("NoSuchEntity", "No such entity", nil)
}
response := &iam.GetInstanceProfileOutput{
InstanceProfile: ip,
}
return response, nil
}
func (m *MockIAM) GetInstanceProfileWithContext(aws.Context, *iam.GetInstanceProfileInput, ...request.Option) (*iam.GetInstanceProfileOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) GetInstanceProfileRequest(*iam.GetInstanceProfileInput) (*request.Request, *iam.GetInstanceProfileOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) CreateInstanceProfile(request *iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateInstanceProfile: %v", request)
p := &iam.InstanceProfile{
InstanceProfileName: request.InstanceProfileName,
// Arn: request.Arn,
// InstanceProfileId: request.InstanceProfileId,
Path: request.Path,
// Roles: request.Roles,
}
// TODO: Some fields
// // The date when the instance profile was created.
// //
// // CreateDate is a required field
// CreateDate *time.Time `type:"timestamp" timestampFormat:"iso8601" required:"true"`
// // The stable and unique string identifying the instance profile. For more information
// // about IDs, see IAM Identifiers (http://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
// // in the Using IAM guide.
// //
// // InstanceProfileId is a required field
// InstanceProfileId *string `min:"16" type:"string" required:"true"`
if m.InstanceProfiles == nil {
m.InstanceProfiles = make(map[string]*iam.InstanceProfile)
}
m.InstanceProfiles[*p.InstanceProfileName] = p
copy := *p
return &iam.CreateInstanceProfileOutput{InstanceProfile: &copy}, nil
}
func (m *MockIAM) CreateInstanceProfileWithContext(aws.Context, *iam.CreateInstanceProfileInput, ...request.Option) (*iam.CreateInstanceProfileOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) CreateInstanceProfileRequest(*iam.CreateInstanceProfileInput) (*request.Request, *iam.CreateInstanceProfileOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) AddRoleToInstanceProfile(request *iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("AddRoleToInstanceProfile: %v", request)
ip := m.InstanceProfiles[aws.StringValue(request.InstanceProfileName)]
if ip == nil {
return nil, fmt.Errorf("InstanceProfile not found")
}
r := m.Roles[aws.StringValue(request.RoleName)]
if r == nil {
return nil, fmt.Errorf("Role not found")
}
ip.Roles = append(ip.Roles, r)
return &iam.AddRoleToInstanceProfileOutput{}, nil
}
func (m *MockIAM) AddRoleToInstanceProfileWithContext(aws.Context, *iam.AddRoleToInstanceProfileInput, ...request.Option) (*iam.AddRoleToInstanceProfileOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) AddRoleToInstanceProfileRequest(*iam.AddRoleToInstanceProfileInput) (*request.Request, *iam.AddRoleToInstanceProfileOutput) {
panic("Not implemented")
return nil, nil
}

79
cloudmock/aws/mockiam/iamrole.go Normal file
View File

@ -0,0 +1,79 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockiam
import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/golang/glog"
)
func (m *MockIAM) GetRole(request *iam.GetRoleInput) (*iam.GetRoleOutput, error) {
role := m.Roles[aws.StringValue(request.RoleName)]
if role == nil {
return nil, awserr.New("NoSuchEntity", "No such entity", nil)
}
response := &iam.GetRoleOutput{
Role: role,
}
return response, nil
}
func (m *MockIAM) GetRoleWithContext(aws.Context, *iam.GetRoleInput, ...request.Option) (*iam.GetRoleOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) GetRoleRequest(*iam.GetRoleInput) (*request.Request, *iam.GetRoleOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) CreateRole(request *iam.CreateRoleInput) (*iam.CreateRoleOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("CreateRole: %v", request)
roleID := m.createID()
r := &iam.Role{
AssumeRolePolicyDocument: request.AssumeRolePolicyDocument,
Description: request.Description,
Path: request.Path,
RoleName: request.RoleName,
RoleId: &roleID,
}
if m.Roles == nil {
m.Roles = make(map[string]*iam.Role)
}
m.Roles[*r.RoleName] = r
copy := *r
return &iam.CreateRoleOutput{Role: &copy}, nil
}
func (m *MockIAM) CreateRoleWithContext(aws.Context, *iam.CreateRoleInput, ...request.Option) (*iam.CreateRoleOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) CreateRoleRequest(*iam.CreateRoleInput) (*request.Request, *iam.CreateRoleOutput) {
panic("Not implemented")
return nil, nil
}

97
cloudmock/aws/mockiam/iamrolepolicy.go Normal file
View File

@ -0,0 +1,97 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package mockiam
import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/golang/glog"
)
type rolePolicy struct {
PolicyDocument string
PolicyName string
RoleName string
}
func (m *MockIAM) GetRolePolicy(request *iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error) {
for _, rp := range m.RolePolicies {
if rp.PolicyName != aws.StringValue(request.PolicyName) {
// TODO: check regex?
continue
}
if rp.RoleName != aws.StringValue(request.RoleName) {
// TODO: check regex?
continue
}
response := &iam.GetRolePolicyOutput{
RoleName: aws.String(rp.RoleName),
PolicyDocument: aws.String(rp.PolicyDocument),
PolicyName: aws.String(rp.PolicyName),
}
return response, nil
}
return nil, awserr.New("NoSuchEntity", "No such entity", nil)
}
func (m *MockIAM) GetRolePolicyWithContext(aws.Context, *iam.GetRolePolicyInput, ...request.Option) (*iam.GetRolePolicyOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) GetRolePolicyRequest(*iam.GetRolePolicyInput) (*request.Request, *iam.GetRolePolicyOutput) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) PutRolePolicy(request *iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error) {
m.mutex.Lock()
defer m.mutex.Unlock()
glog.Infof("PutRolePolicy: %v", request)
for _, rp := range m.RolePolicies {
if rp.PolicyName != aws.StringValue(request.PolicyName) {
// TODO: check regex?
continue
}
if rp.RoleName != aws.StringValue(request.RoleName) {
// TODO: check regex?
continue
}
rp.PolicyDocument = aws.StringValue(request.PolicyDocument)
return &iam.PutRolePolicyOutput{}, nil
}
m.RolePolicies = append(m.RolePolicies, &rolePolicy{
PolicyDocument: aws.StringValue(request.PolicyDocument),
PolicyName: aws.StringValue(request.PolicyName),
RoleName: aws.StringValue(request.RoleName),
})
return &iam.PutRolePolicyOutput{}, nil
}
func (m *MockIAM) PutRolePolicyWithContext(aws.Context, *iam.PutRolePolicyInput, ...request.Option) (*iam.PutRolePolicyOutput, error) {
panic("Not implemented")
return nil, nil
}
func (m *MockIAM) PutRolePolicyRequest(*iam.PutRolePolicyInput) (*request.Request, *iam.PutRolePolicyOutput) {
panic("Not implemented")
return nil, nil
}

1629
cloudmock/aws/mockiam/unimplemented.go Normal file
View File

File diff suppressed because it is too large Load Diff

1
cmd/kops/BUILD.bazel
View File

@ -138,6 +138,7 @@ go_test(
"createcluster_test.go",
"delete_confirm_test.go",
"integration_test.go",
"lifecycle_integration_test.go",
],
data = [
"//channels:channeldata", # keep

4
cmd/kops/create_cluster.go
View File

@ -457,7 +457,7 @@ func RunCreateCluster(f *util.Factory, out io.Writer, c *CreateClusterOptions) e
SubnetIds: []*string{aws.String(c.SubnetIDs[0])},
})
if err != nil {
return fmt.Errorf("error describing subnet %s", c.SubnetIDs[0])
return fmt.Errorf("error describing subnet %s: %v", c.SubnetIDs[0], err)
}
if len(res.Subnets) == 0 || res.Subnets[0].VpcId == nil {
return fmt.Errorf("failed to determine VPC id of subnet %s", c.SubnetIDs[0])
@ -1152,7 +1152,7 @@ func RunCreateCluster(f *util.Factory, out io.Writer, c *CreateClusterOptions) e
// updateClusterOptions.MaxTaskDuration = c.MaxTaskDuration
// updateClusterOptions.CreateKubecfg = c.CreateKubecfg
err := RunUpdateCluster(f, clusterName, out, updateClusterOptions)
_, err := RunUpdateCluster(f, clusterName, out, updateClusterOptions)
if err != nil {
return err
}

4
cmd/kops/integration_test.go
View File

@ -213,7 +213,7 @@ func runTest(t *testing.T, h *testutils.IntegrationTestHarness, clusterName stri
// We don't test it here, and it adds a dependency on kubectl
options.CreateKubecfg = false
err := RunUpdateCluster(factory, clusterName, &stdout, options)
_, err := RunUpdateCluster(factory, clusterName, &stdout, options)
if err != nil {
t.Fatalf("error running update cluster %q: %v", clusterName, err)
}
@ -475,7 +475,7 @@ func runTestCloudformation(t *testing.T, clusterName string, srcDir string, vers
// We don't test it here, and it adds a dependency on kubectl
options.CreateKubecfg = false
err := RunUpdateCluster(factory, clusterName, &stdout, options)
_, err := RunUpdateCluster(factory, clusterName, &stdout, options)
if err != nil {
t.Fatalf("error running update cluster %q: %v", clusterName, err)
}

142
cmd/kops/lifecycle_integration_test.go Normal file
View File

@ -0,0 +1,142 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"bytes"
"path"
"testing"
"time"
"k8s.io/kops/upup/pkg/fi"
"k8s.io/kops/cmd/kops/util"
"k8s.io/kops/pkg/testutils"
"k8s.io/kops/upup/pkg/fi/cloudup"
)
type LifecycleTestOptions struct {
t *testing.T
SrcDir string
Version string
ClusterName string
}
func (o *LifecycleTestOptions) AddDefaults() {
if o.Version == "" {
o.Version = "v1alpha2"
}
if o.ClusterName == "" {
o.ClusterName = o.SrcDir + ".example.com"
}
o.SrcDir = "../../tests/integration/update_cluster/" + o.SrcDir
}
// TestLifecycleMinimal runs the test on a minimum configuration, similar to kops create cluster minimal.example.com --zones us-west-1a
func TestLifecycleMinimal(t *testing.T) {
runLifecycleTestAWS(&LifecycleTestOptions{
t: t,
SrcDir: "minimal",
})
}
func runLifecycleTest(h *testutils.IntegrationTestHarness, o *LifecycleTestOptions) {
t := o.t
var stdout bytes.Buffer
inputYAML := "in-" + o.Version + ".yaml"
factoryOptions := &util.FactoryOptions{}
factoryOptions.RegistryPath = "memfs://tests"
factory := util.NewFactory(factoryOptions)
{
options := &CreateOptions{}
options.Filenames = []string{path.Join(o.SrcDir, inputYAML)}
err := RunCreate(factory, &stdout, options)
if err != nil {
t.Fatalf("error running %q create: %v", inputYAML, err)
}
}
{
options := &CreateSecretPublickeyOptions{}
options.ClusterName = o.ClusterName
options.Name = "admin"
options.PublicKeyPath = path.Join(o.SrcDir, "id_rsa.pub")
err := RunCreateSecretPublicKey(factory, &stdout, options)
if err != nil {
t.Fatalf("error running %q create: %v", inputYAML, err)
}
}
{
options := &UpdateClusterOptions{}
options.InitDefaults()
options.MaxTaskDuration = 10 * time.Second
options.Yes = true
// We don't test it here, and it adds a dependency on kubectl
options.CreateKubecfg = false
_, err := RunUpdateCluster(factory, o.ClusterName, &stdout, options)
if err != nil {
t.Fatalf("error running update cluster %q: %v", o.ClusterName, err)
}
}
{
options := &UpdateClusterOptions{}
options.InitDefaults()
options.Target = cloudup.TargetDryRun
options.MaxTaskDuration = 10 * time.Second
// We don't test it here, and it adds a dependency on kubectl
options.CreateKubecfg = false
results, err := RunUpdateCluster(factory, o.ClusterName, &stdout, options)
if err != nil {
t.Fatalf("error running update cluster %q: %v", o.ClusterName, err)
}
target := results.Target.(*fi.DryRunTarget)
if target.HasChanges() {
var b bytes.Buffer
if err := target.PrintReport(results.TaskMap, &b); err != nil {
t.Fatalf("error building report: %v", err)
}
t.Fatalf("Target had changes after executing: %v", b.String())
}
}
}
func runLifecycleTestAWS(o *LifecycleTestOptions) {
o.AddDefaults()
h := testutils.NewIntegrationTestHarness(o.t)
defer h.Close()
h.MockKopsVersion("1.7.0")
h.SetupMockAWS()
runLifecycleTest(h, o)
}

52
cmd/kops/update_cluster.go
View File

@ -100,8 +100,7 @@ func NewCmdUpdateCluster(f *util.Factory, out io.Writer) *cobra.Command {
clusterName := rootCommand.ClusterName()
err = RunUpdateCluster(f, clusterName, out, options)
if err != nil {
if _, err := RunUpdateCluster(f, clusterName, out, options); err != nil {
exitWithError(err)
}
},
@ -119,7 +118,17 @@ func NewCmdUpdateCluster(f *util.Factory, out io.Writer) *cobra.Command {
return cmd
}
func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *UpdateClusterOptions) error {
type UpdateClusterResults struct {
// Target is the fi.Target we will operated against. This can be used to get dryrun results (primarily for tests)
Target fi.Target
// TaskMap is the map of tasks that we built (output)
TaskMap map[string]fi.Task
}
func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *UpdateClusterOptions) (*UpdateClusterResults, error) {
results := &UpdateClusterResults{}
isDryrun := false
targetName := c.Target
@ -147,27 +156,27 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
cluster, err := GetCluster(f, clusterName)
if err != nil {
return err
return results, err
}
clientset, err := f.Clientset()
if err != nil {
return err
return results, err
}
keyStore, err := clientset.KeyStore(cluster)
if err != nil {
return err
return results, err
}
sshCredentialStore, err := clientset.SSHCredentialStore(cluster)
if err != nil {
return err
return results, err
}
secretStore, err := clientset.SecretStore(cluster)
if err != nil {
return err
return results, err
}
if c.SSHPublicKey != "" {
@ -176,11 +185,11 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
c.SSHPublicKey = utils.ExpandPath(c.SSHPublicKey)
authorized, err := ioutil.ReadFile(c.SSHPublicKey)
if err != nil {
return fmt.Errorf("error reading SSH key file %q: %v", c.SSHPublicKey, err)
return results, fmt.Errorf("error reading SSH key file %q: %v", c.SSHPublicKey, err)
}
err = sshCredentialStore.AddSSHPublicKey(fi.SecretNameSSHPrimary, authorized)
if err != nil {
return fmt.Errorf("error adding SSH public key: %v", err)
return results, fmt.Errorf("error adding SSH public key: %v", err)
}
glog.Infof("Using SSH public key: %v\n", c.SSHPublicKey)
@ -198,7 +207,7 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
case string(cloudup.PhaseCluster):
phase = cloudup.PhaseCluster
default:
return fmt.Errorf("unknown phase %q, available phases: %s", c.Phase, strings.Join(cloudup.Phases.List(), ","))
return results, fmt.Errorf("unknown phase %q, available phases: %s", c.Phase, strings.Join(cloudup.Phases.List(), ","))
}
}
@ -207,7 +216,7 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
for _, override := range c.LifecycleOverrides {
values := strings.Split(override, "=")
if len(values) != 2 {
return fmt.Errorf("Incorrect syntax for lifecyle-overrides, correct syntax is TaskName=lifecycleName, override provided: %q", override)
return results, fmt.Errorf("Incorrect syntax for lifecyle-overrides, correct syntax is TaskName=lifecycleName, override provided: %q", override)
}
taskName := values[0]
@ -215,7 +224,7 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
lifecycleOverride, err := parseLifecycle(lifecycleName)
if err != nil {
return err
return nil, err
}
lifecycleOverrideMap[taskName] = lifecycleOverride
@ -225,7 +234,7 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
{
list, err := clientset.InstanceGroupsFor(cluster).List(metav1.ListOptions{})
if err != nil {
return err
return nil, err
}
for i := range list.Items {
instanceGroups = append(instanceGroups, &list.Items[i])
@ -246,9 +255,12 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
}
if err := applyCmd.Run(); err != nil {
return err
return results, err
}
results.Target = applyCmd.Target
results.TaskMap = applyCmd.TaskMap
if isDryrun {
target := applyCmd.Target.(*fi.DryRunTarget)
if target.HasChanges() {
@ -256,7 +268,7 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
} else {
fmt.Fprintf(out, "No changes need to be applied\n")
}
return nil
return results, nil
}
firstRun := false
@ -279,11 +291,11 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
glog.Infof("Exporting kubecfg for cluster")
conf, err := kubeconfig.BuildKubecfg(cluster, keyStore, secretStore, &commands.CloudDiscoveryStatusStore{})
if err != nil {
return err
return nil, err
}
err = conf.WriteKubecfg()
if err != nil {
return err
return nil, err
}
} else {
glog.Infof("kubecfg cert not found; won't export kubecfg")
@ -355,11 +367,11 @@ func RunUpdateCluster(f *util.Factory, clusterName string, out io.Writer, c *Upd
_, err := out.Write(sb.Bytes())
if err != nil {
return fmt.Errorf("error writing to output: %v", err)
return nil, fmt.Errorf("error writing to output: %v", err)
}
}
return nil
return results, nil
}
func parseLifecycle(lifecycle string) (fi.Lifecycle, error) {

1
hack/.packages
View File

@ -6,6 +6,7 @@ k8s.io/kops/channels/pkg/cmd
k8s.io/kops/cloudmock/aws/mockautoscaling
k8s.io/kops/cloudmock/aws/mockec2
k8s.io/kops/cloudmock/aws/mockelb
k8s.io/kops/cloudmock/aws/mockiam
k8s.io/kops/cloudmock/aws/mockroute53
k8s.io/kops/cmd/kops
k8s.io/kops/cmd/kops/util

8
pkg/instancegroups/rollingupdate_test.go
View File

@ -327,7 +327,7 @@ func TestRollingUpdateNoneNeedUpdate(t *testing.T) {
})
for _, group := range asgGroups.AutoScalingGroups {
if len(group.Instances) != 2 {
t.Errorf("Expected 2 instances got: %v", len(group.Instances))
t.Errorf("Expected 2 instances got: %v in %v", len(group.Instances), group)
}
}
@ -336,7 +336,7 @@ func TestRollingUpdateNoneNeedUpdate(t *testing.T) {
})
for _, group := range asgGroups.AutoScalingGroups {
if len(group.Instances) != 2 {
t.Errorf("Expected 2 instances got: %v", len(group.Instances))
t.Errorf("Expected 2 instances got: %v in %v", len(group.Instances), group)
}
}
@ -345,7 +345,7 @@ func TestRollingUpdateNoneNeedUpdate(t *testing.T) {
})
for _, group := range asgGroups.AutoScalingGroups {
if len(group.Instances) != 1 {
t.Errorf("Expected 1 instances got: %v", len(group.Instances))
t.Errorf("Expected 1 instance got: %v in %v", len(group.Instances), group)
}
}
@ -354,7 +354,7 @@ func TestRollingUpdateNoneNeedUpdate(t *testing.T) {
})
for _, group := range asgGroups.AutoScalingGroups {
if len(group.Instances) != 1 {
t.Errorf("Expected 1 instances got: %v", len(group.Instances))
t.Errorf("Expected 1 instance got: %v in %v", len(group.Instances), group)
}
}
}

1
pkg/pki/BUILD.bazel
View File

@ -11,7 +11,6 @@ go_library(
importpath = "k8s.io/kops/pkg/pki",
visibility = ["//visibility:public"],
deps = [
"//upup/pkg/fi/utils:go_default_library",
"//vendor/github.com/golang/glog:go_default_library",
"//vendor/golang.org/x/crypto/ssh:go_default_library",
],

6
pkg/pki/sshkey.go
View File

@ -28,8 +28,6 @@ import (
"strings"
"golang.org/x/crypto/ssh"
"k8s.io/kops/upup/pkg/fi/utils"
)
// parseSSHPublicKey parses the SSH public key string
@ -99,11 +97,11 @@ func ComputeOpenSSHKeyFingerprint(publicKey string) (string, error) {
// Annoyingly, the ssh code wraps the actual crypto keys, so we have to use reflection tricks
func toDER(pubkey ssh.PublicKey) ([]byte, error) {
pubkeyValue := reflect.ValueOf(pubkey)
typeName := utils.BuildTypeName(pubkeyValue.Type())
typeName := fmt.Sprintf("%T", pubkey)
var cryptoKey crypto.PublicKey
switch typeName {
case "*rsaPublicKey":
case "*ssh.rsaPublicKey":
var rsaPublicKey *rsa.PublicKey
targetType := reflect.ValueOf(rsaPublicKey).Type()
rsaPublicKey = pubkeyValue.Convert(targetType).Interface().(*rsa.PublicKey)

30
pkg/resources/aws_test.go
View File

@ -37,15 +37,15 @@ func TestAddUntaggedRouteTables(t *testing.T) {
cloud.MockEC2 = c
// Matches by vpc id
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-1234"),
RouteTableId: aws.String("rt-1234"),
RouteTableId: aws.String("rtb-1234"),
})
// Skips main route tables
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-1234"),
RouteTableId: aws.String("rt-1234main"),
RouteTableId: aws.String("rtb-1234main"),
Associations: []*ec2.RouteTableAssociation{
{
Main: aws.Bool(true),
@ -54,9 +54,9 @@ func TestAddUntaggedRouteTables(t *testing.T) {
})
// Skips route table tagged with other cluster
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-1234"),
RouteTableId: aws.String("rt-1234main"),
RouteTableId: aws.String("rtb-1234notmain"),
Tags: []*ec2.Tag{
{
Key: aws.String(awsup.TagClusterName),
@ -66,9 +66,9 @@ func TestAddUntaggedRouteTables(t *testing.T) {
})
// Ignores non-matching vpcs
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-5555"),
RouteTableId: aws.String("rt-5555"),
RouteTableId: aws.String("rtb-5555"),
})
resources["vpc:vpc-1234"] = &Resource{}
@ -83,7 +83,7 @@ func TestAddUntaggedRouteTables(t *testing.T) {
keys = append(keys, k)
}
sort.Strings(keys)
expected := []string{"route-table:rt-1234", "vpc:vpc-1234"}
expected := []string{"route-table:rtb-1234", "vpc:vpc-1234"}
if !reflect.DeepEqual(expected, keys) {
t.Fatalf("expected=%q, actual=%q", expected, keys)
}
@ -98,9 +98,9 @@ func TestListRouteTables(t *testing.T) {
c := &mockec2.MockEC2{}
cloud.MockEC2 = c
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-1234"),
RouteTableId: aws.String("rt-shared"),
RouteTableId: aws.String("rtb-shared"),
Tags: []*ec2.Tag{
{
Key: aws.String("KubernetesCluster"),
@ -112,9 +112,9 @@ func TestListRouteTables(t *testing.T) {
},
},
})
c.RouteTables = append(c.RouteTables, &ec2.RouteTable{
c.AddRouteTable(&ec2.RouteTable{
VpcId: aws.String("vpc-1234"),
RouteTableId: aws.String("rt-owned"),
RouteTableId: aws.String("rtb-owned"),
Tags: []*ec2.Tag{
{
Key: aws.String("KubernetesCluster"),
@ -132,10 +132,10 @@ func TestListRouteTables(t *testing.T) {
t.Fatalf("error listing route tables: %v", err)
}
for _, rt := range resources {
if rt.ID == "rt-shared" && !rt.Shared {
if rt.ID == "rtb-shared" && !rt.Shared {
t.Fatalf("expected Shared: true, got: %v", rt.Shared)
}
if rt.ID == "rt-owned" && rt.Shared {
if rt.ID == "rtb-owned" && rt.Shared {
t.Fatalf("expected Shared: false, got: %v", rt.Shared)
}
}

2
pkg/testutils/BUILD.bazel
View File

@ -7,8 +7,10 @@ go_library(
visibility = ["//visibility:public"],
deps = [
"//:go_default_library",
"//cloudmock/aws/mockautoscaling:go_default_library",
"//cloudmock/aws/mockec2:go_default_library",
"//cloudmock/aws/mockelb:go_default_library",
"//cloudmock/aws/mockiam:go_default_library",
"//cloudmock/aws/mockroute53:go_default_library",
"//pkg/apis/kops:go_default_library",
"//upup/pkg/fi/cloudup/awsup:go_default_library",

6
pkg/testutils/integrationtestharness.go
View File

@ -28,8 +28,10 @@ import (
"github.com/aws/aws-sdk-go/service/route53"
"github.com/golang/glog"
kopsroot "k8s.io/kops"
"k8s.io/kops/cloudmock/aws/mockautoscaling"
"k8s.io/kops/cloudmock/aws/mockec2"
"k8s.io/kops/cloudmock/aws/mockelb"
"k8s.io/kops/cloudmock/aws/mockiam"
"k8s.io/kops/cloudmock/aws/mockroute53"
"k8s.io/kops/pkg/apis/kops"
"k8s.io/kops/upup/pkg/fi/cloudup/awsup"
@ -101,6 +103,10 @@ func (h *IntegrationTestHarness) SetupMockAWS() {
cloud.MockRoute53 = mockRoute53
mockELB := &mockelb.MockELB{}
cloud.MockELB = mockELB
mockIAM := &mockiam.MockIAM{}
cloud.MockIAM = mockIAM
mockAutoscaling := &mockautoscaling.MockAutoscaling{}
cloud.MockAutoscaling = mockAutoscaling
mockRoute53.MockCreateZone(&route53.HostedZone{
Id: aws.String("/hostedzone/Z1AFAKE1ZON3YO"),

5
upup/pkg/fi/cloudup/apply_cluster.go
View File

@ -128,6 +128,9 @@ type ApplyClusterCmd struct {
// The key value is the task name such as InternetGateway and the value is the fi.Lifecycle
// that is re-mapped.
LifecycleOverrides map[string]fi.Lifecycle
// TaskMap is the map of tasks that we built (output)
TaskMap map[string]fi.Task
}
func (c *ApplyClusterCmd) Run() error {
@ -638,6 +641,8 @@ func (c *ApplyClusterCmd) Run() error {
return fmt.Errorf("error building tasks: %v", err)
}
c.TaskMap = taskMap
var target fi.Target
dryRun := false
shouldPrecreateDNS := true

2
upup/pkg/fi/cloudup/awstasks/iamrole.go
View File

@ -107,7 +107,7 @@ func (e *IAMRole) Find(c *fi.Context) (*IAMRole, error) {
actual.RolePolicyDocument = fi.WrapResource(fi.NewStringResource(actualPolicy))
}
glog.V(2).Infof("found matching IAMRole %q", *actual.ID)
glog.V(2).Infof("found matching IAMRole %q", aws.StringValue(actual.ID))
e.ID = actual.ID
// Avoid spurious changes

2
upup/pkg/fi/cloudup/awstasks/securitygroup_test.go
View File

@ -149,7 +149,7 @@ func TestSecurityGroupCreate(t *testing.T) {
VpcId: vpc1.ID,
GroupName: s("sg1"),
}
actual := c.SecurityGroups[0]
actual := c.SecurityGroups[*sg1.ID]
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("Unexpected SecurityGroup: expected=%v actual=%v", expected, actual)
}

1
upup/pkg/fi/cloudup/awsup/BUILD.bazel
View File

@ -36,6 +36,7 @@ go_library(
"//vendor/github.com/aws/aws-sdk-go/service/elb:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/elb/elbiface:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/iam:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/iam/iamiface:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/route53:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/route53/route53iface:go_default_library",
"//vendor/github.com/golang/glog:go_default_library",

5
upup/pkg/fi/cloudup/awsup/aws_cloud.go
View File

@ -34,6 +34,7 @@ import (
"github.com/aws/aws-sdk-go/service/elb"
"github.com/aws/aws-sdk-go/service/elb/elbiface"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/aws/aws-sdk-go/service/iam/iamiface"
"github.com/aws/aws-sdk-go/service/route53"
"github.com/aws/aws-sdk-go/service/route53/route53iface"
"github.com/golang/glog"
@ -86,7 +87,7 @@ type AWSCloud interface {
CloudFormation() *cloudformation.CloudFormation
EC2() ec2iface.EC2API
IAM() *iam.IAM
IAM() iamiface.IAMAPI
ELB() elbiface.ELBAPI
Autoscaling() autoscalingiface.AutoScalingAPI
Route53() route53iface.Route53API
@ -1027,7 +1028,7 @@ func (c *awsCloudImplementation) EC2() ec2iface.EC2API {
return c.ec2
}
func (c *awsCloudImplementation) IAM() *iam.IAM {
func (c *awsCloudImplementation) IAM() iamiface.IAMAPI {
return c.iam
}

13
upup/pkg/fi/cloudup/awsup/mock_aws_cloud.go
View File

@ -25,7 +25,7 @@ import (
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
"github.com/aws/aws-sdk-go/service/elb/elbiface"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/aws/aws-sdk-go/service/iam/iamiface"
"github.com/aws/aws-sdk-go/service/route53/route53iface"
"github.com/golang/glog"
"k8s.io/api/core/v1"
@ -73,6 +73,7 @@ type MockCloud struct {
MockAutoscaling autoscalingiface.AutoScalingAPI
MockCloudFormation *cloudformation.CloudFormation
MockEC2 ec2iface.EC2API
MockIAM iamiface.IAMAPI
MockRoute53 route53iface.Route53API
MockELB elbiface.ELBAPI
}
@ -190,9 +191,11 @@ func (c *MockAWSCloud) EC2() ec2iface.EC2API {
return c.MockEC2
}
func (c *MockAWSCloud) IAM() *iam.IAM {
glog.Fatalf("MockAWSCloud IAM not implemented")
return nil
func (c *MockAWSCloud) IAM() iamiface.IAMAPI {
if c.MockIAM == nil {
glog.Fatalf("MockAWSCloud MockIAM not set")
}
return c.MockIAM
}
func (c *MockAWSCloud) ELB() elbiface.ELBAPI {
@ -204,7 +207,7 @@ func (c *MockAWSCloud) ELB() elbiface.ELBAPI {
func (c *MockAWSCloud) Autoscaling() autoscalingiface.AutoScalingAPI {
if c.MockAutoscaling == nil {
glog.Fatalf("MockAWSCloud Autoscaling not implemented")
glog.Fatalf("MockAWSCloud Autoscaling not set")
}
return c.MockAutoscaling
}

13
vendor/github.com/aws/aws-sdk-go/service/iam/iamiface/BUILD.bazel generated vendored Normal file
View File

@ -0,0 +1,13 @@
load("@io_bazel_rules_go//go:def.bzl", "go_library")
go_library(
name = "go_default_library",
srcs = ["interface.go"],
importpath = "github.com/aws/aws-sdk-go/service/iam/iamiface",
visibility = ["//visibility:public"],
deps = [
"//vendor/github.com/aws/aws-sdk-go/aws:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/aws/request:go_default_library",
"//vendor/github.com/aws/aws-sdk-go/service/iam:go_default_library",
],
)

636
vendor/github.com/aws/aws-sdk-go/service/iam/iamiface/interface.go generated vendored Normal file
View File

@ -0,0 +1,636 @@
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
// Package iamiface provides an interface to enable mocking the AWS Identity and Access Management service client
// for testing your code.
//
// It is important to note that this interface will have breaking changes
// when the service model is updated and adds new API operations, paginators,
// and waiters.
package iamiface
import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/service/iam"
)
// IAMAPI provides an interface to enable mocking the
// iam.IAM service client's API operation,
// paginators, and waiters. This make unit testing your code that calls out
// to the SDK's service client's calls easier.
//
// The best way to use this interface is so the SDK's service client's calls
// can be stubbed out for unit testing your code with the SDK without needing
// to inject custom request handlers into the SDK's request pipeline.
//
// // myFunc uses an SDK service client to make a request to
// // AWS Identity and Access Management.
// func myFunc(svc iamiface.IAMAPI) bool {
// // Make svc.AddClientIDToOpenIDConnectProvider request
// }
//
// func main() {
// sess := session.New()
// svc := iam.New(sess)
//
// myFunc(svc)
// }
//
// In your _test.go file:
//
// // Define a mock struct to be used in your unit tests of myFunc.
// type mockIAMClient struct {
// iamiface.IAMAPI
// }
// func (m *mockIAMClient) AddClientIDToOpenIDConnectProvider(input *iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) {
// // mock response/functionality
// }
//
// func TestMyFunc(t *testing.T) {
// // Setup Test
// mockSvc := &mockIAMClient{}
//
// myfunc(mockSvc)
//
// // Verify myFunc's functionality
// }
//
// It is important to note that this interface will have breaking changes
// when the service model is updated and adds new API operations, paginators,
// and waiters. Its suggested to use the pattern above for testing, or using
// tooling to generate mocks to satisfy the interfaces.
type IAMAPI interface {
AddClientIDToOpenIDConnectProvider(*iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error)
AddClientIDToOpenIDConnectProviderWithContext(aws.Context, *iam.AddClientIDToOpenIDConnectProviderInput, ...request.Option) (*iam.AddClientIDToOpenIDConnectProviderOutput, error)
AddClientIDToOpenIDConnectProviderRequest(*iam.AddClientIDToOpenIDConnectProviderInput) (*request.Request, *iam.AddClientIDToOpenIDConnectProviderOutput)
AddRoleToInstanceProfile(*iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error)
AddRoleToInstanceProfileWithContext(aws.Context, *iam.AddRoleToInstanceProfileInput, ...request.Option) (*iam.AddRoleToInstanceProfileOutput, error)
AddRoleToInstanceProfileRequest(*iam.AddRoleToInstanceProfileInput) (*request.Request, *iam.AddRoleToInstanceProfileOutput)
AddUserToGroup(*iam.AddUserToGroupInput) (*iam.AddUserToGroupOutput, error)
AddUserToGroupWithContext(aws.Context, *iam.AddUserToGroupInput, ...request.Option) (*iam.AddUserToGroupOutput, error)
AddUserToGroupRequest(*iam.AddUserToGroupInput) (*request.Request, *iam.AddUserToGroupOutput)
AttachGroupPolicy(*iam.AttachGroupPolicyInput) (*iam.AttachGroupPolicyOutput, error)
AttachGroupPolicyWithContext(aws.Context, *iam.AttachGroupPolicyInput, ...request.Option) (*iam.AttachGroupPolicyOutput, error)
AttachGroupPolicyRequest(*iam.AttachGroupPolicyInput) (*request.Request, *iam.AttachGroupPolicyOutput)
AttachRolePolicy(*iam.AttachRolePolicyInput) (*iam.AttachRolePolicyOutput, error)
AttachRolePolicyWithContext(aws.Context, *iam.AttachRolePolicyInput, ...request.Option) (*iam.AttachRolePolicyOutput, error)
AttachRolePolicyRequest(*iam.AttachRolePolicyInput) (*request.Request, *iam.AttachRolePolicyOutput)
AttachUserPolicy(*iam.AttachUserPolicyInput) (*iam.AttachUserPolicyOutput, error)
AttachUserPolicyWithContext(aws.Context, *iam.AttachUserPolicyInput, ...request.Option) (*iam.AttachUserPolicyOutput, error)
AttachUserPolicyRequest(*iam.AttachUserPolicyInput) (*request.Request, *iam.AttachUserPolicyOutput)
ChangePassword(*iam.ChangePasswordInput) (*iam.ChangePasswordOutput, error)
ChangePasswordWithContext(aws.Context, *iam.ChangePasswordInput, ...request.Option) (*iam.ChangePasswordOutput, error)
ChangePasswordRequest(*iam.ChangePasswordInput) (*request.Request, *iam.ChangePasswordOutput)
CreateAccessKey(*iam.CreateAccessKeyInput) (*iam.CreateAccessKeyOutput, error)
CreateAccessKeyWithContext(aws.Context, *iam.CreateAccessKeyInput, ...request.Option) (*iam.CreateAccessKeyOutput, error)
CreateAccessKeyRequest(*iam.CreateAccessKeyInput) (*request.Request, *iam.CreateAccessKeyOutput)
CreateAccountAlias(*iam.CreateAccountAliasInput) (*iam.CreateAccountAliasOutput, error)
CreateAccountAliasWithContext(aws.Context, *iam.CreateAccountAliasInput, ...request.Option) (*iam.CreateAccountAliasOutput, error)
CreateAccountAliasRequest(*iam.CreateAccountAliasInput) (*request.Request, *iam.CreateAccountAliasOutput)
CreateGroup(*iam.CreateGroupInput) (*iam.CreateGroupOutput, error)
CreateGroupWithContext(aws.Context, *iam.CreateGroupInput, ...request.Option) (*iam.CreateGroupOutput, error)
CreateGroupRequest(*iam.CreateGroupInput) (*request.Request, *iam.CreateGroupOutput)
CreateInstanceProfile(*iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error)
CreateInstanceProfileWithContext(aws.Context, *iam.CreateInstanceProfileInput, ...request.Option) (*iam.CreateInstanceProfileOutput, error)
CreateInstanceProfileRequest(*iam.CreateInstanceProfileInput) (*request.Request, *iam.CreateInstanceProfileOutput)
CreateLoginProfile(*iam.CreateLoginProfileInput) (*iam.CreateLoginProfileOutput, error)
CreateLoginProfileWithContext(aws.Context, *iam.CreateLoginProfileInput, ...request.Option) (*iam.CreateLoginProfileOutput, error)
CreateLoginProfileRequest(*iam.CreateLoginProfileInput) (*request.Request, *iam.CreateLoginProfileOutput)
CreateOpenIDConnectProvider(*iam.CreateOpenIDConnectProviderInput) (*iam.CreateOpenIDConnectProviderOutput, error)
CreateOpenIDConnectProviderWithContext(aws.Context, *iam.CreateOpenIDConnectProviderInput, ...request.Option) (*iam.CreateOpenIDConnectProviderOutput, error)
CreateOpenIDConnectProviderRequest(*iam.CreateOpenIDConnectProviderInput) (*request.Request, *iam.CreateOpenIDConnectProviderOutput)
CreatePolicy(*iam.CreatePolicyInput) (*iam.CreatePolicyOutput, error)
CreatePolicyWithContext(aws.Context, *iam.CreatePolicyInput, ...request.Option) (*iam.CreatePolicyOutput, error)
CreatePolicyRequest(*iam.CreatePolicyInput) (*request.Request, *iam.CreatePolicyOutput)
CreatePolicyVersion(*iam.CreatePolicyVersionInput) (*iam.CreatePolicyVersionOutput, error)
CreatePolicyVersionWithContext(aws.Context, *iam.CreatePolicyVersionInput, ...request.Option) (*iam.CreatePolicyVersionOutput, error)
CreatePolicyVersionRequest(*iam.CreatePolicyVersionInput) (*request.Request, *iam.CreatePolicyVersionOutput)
CreateRole(*iam.CreateRoleInput) (*iam.CreateRoleOutput, error)
CreateRoleWithContext(aws.Context, *iam.CreateRoleInput, ...request.Option) (*iam.CreateRoleOutput, error)
CreateRoleRequest(*iam.CreateRoleInput) (*request.Request, *iam.CreateRoleOutput)
CreateSAMLProvider(*iam.CreateSAMLProviderInput) (*iam.CreateSAMLProviderOutput, error)
CreateSAMLProviderWithContext(aws.Context, *iam.CreateSAMLProviderInput, ...request.Option) (*iam.CreateSAMLProviderOutput, error)
CreateSAMLProviderRequest(*iam.CreateSAMLProviderInput) (*request.Request, *iam.CreateSAMLProviderOutput)
CreateServiceLinkedRole(*iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error)
CreateServiceLinkedRoleWithContext(aws.Context, *iam.CreateServiceLinkedRoleInput, ...request.Option) (*iam.CreateServiceLinkedRoleOutput, error)
CreateServiceLinkedRoleRequest(*iam.CreateServiceLinkedRoleInput) (*request.Request, *iam.CreateServiceLinkedRoleOutput)
CreateServiceSpecificCredential(*iam.CreateServiceSpecificCredentialInput) (*iam.CreateServiceSpecificCredentialOutput, error)
CreateServiceSpecificCredentialWithContext(aws.Context, *iam.CreateServiceSpecificCredentialInput, ...request.Option) (*iam.CreateServiceSpecificCredentialOutput, error)
CreateServiceSpecificCredentialRequest(*iam.CreateServiceSpecificCredentialInput) (*request.Request, *iam.CreateServiceSpecificCredentialOutput)
CreateUser(*iam.CreateUserInput) (*iam.CreateUserOutput, error)
CreateUserWithContext(aws.Context, *iam.CreateUserInput, ...request.Option) (*iam.CreateUserOutput, error)
CreateUserRequest(*iam.CreateUserInput) (*request.Request, *iam.CreateUserOutput)
CreateVirtualMFADevice(*iam.CreateVirtualMFADeviceInput) (*iam.CreateVirtualMFADeviceOutput, error)
CreateVirtualMFADeviceWithContext(aws.Context, *iam.CreateVirtualMFADeviceInput, ...request.Option) (*iam.CreateVirtualMFADeviceOutput, error)
CreateVirtualMFADeviceRequest(*iam.CreateVirtualMFADeviceInput) (*request.Request, *iam.CreateVirtualMFADeviceOutput)
DeactivateMFADevice(*iam.DeactivateMFADeviceInput) (*iam.DeactivateMFADeviceOutput, error)
DeactivateMFADeviceWithContext(aws.Context, *iam.DeactivateMFADeviceInput, ...request.Option) (*iam.DeactivateMFADeviceOutput, error)
DeactivateMFADeviceRequest(*iam.DeactivateMFADeviceInput) (*request.Request, *iam.DeactivateMFADeviceOutput)
DeleteAccessKey(*iam.DeleteAccessKeyInput) (*iam.DeleteAccessKeyOutput, error)
DeleteAccessKeyWithContext(aws.Context, *iam.DeleteAccessKeyInput, ...request.Option) (*iam.DeleteAccessKeyOutput, error)
DeleteAccessKeyRequest(*iam.DeleteAccessKeyInput) (*request.Request, *iam.DeleteAccessKeyOutput)
DeleteAccountAlias(*iam.DeleteAccountAliasInput) (*iam.DeleteAccountAliasOutput, error)
DeleteAccountAliasWithContext(aws.Context, *iam.DeleteAccountAliasInput, ...request.Option) (*iam.DeleteAccountAliasOutput, error)
DeleteAccountAliasRequest(*iam.DeleteAccountAliasInput) (*request.Request, *iam.DeleteAccountAliasOutput)
DeleteAccountPasswordPolicy(*iam.DeleteAccountPasswordPolicyInput) (*iam.DeleteAccountPasswordPolicyOutput, error)
DeleteAccountPasswordPolicyWithContext(aws.Context, *iam.DeleteAccountPasswordPolicyInput, ...request.Option) (*iam.DeleteAccountPasswordPolicyOutput, error)
DeleteAccountPasswordPolicyRequest(*iam.DeleteAccountPasswordPolicyInput) (*request.Request, *iam.DeleteAccountPasswordPolicyOutput)
DeleteGroup(*iam.DeleteGroupInput) (*iam.DeleteGroupOutput, error)
DeleteGroupWithContext(aws.Context, *iam.DeleteGroupInput, ...request.Option) (*iam.DeleteGroupOutput, error)
DeleteGroupRequest(*iam.DeleteGroupInput) (*request.Request, *iam.DeleteGroupOutput)
DeleteGroupPolicy(*iam.DeleteGroupPolicyInput) (*iam.DeleteGroupPolicyOutput, error)
DeleteGroupPolicyWithContext(aws.Context, *iam.DeleteGroupPolicyInput, ...request.Option) (*iam.DeleteGroupPolicyOutput, error)
DeleteGroupPolicyRequest(*iam.DeleteGroupPolicyInput) (*request.Request, *iam.DeleteGroupPolicyOutput)
DeleteInstanceProfile(*iam.DeleteInstanceProfileInput) (*iam.DeleteInstanceProfileOutput, error)
DeleteInstanceProfileWithContext(aws.Context, *iam.DeleteInstanceProfileInput, ...request.Option) (*iam.DeleteInstanceProfileOutput, error)
DeleteInstanceProfileRequest(*iam.DeleteInstanceProfileInput) (*request.Request, *iam.DeleteInstanceProfileOutput)
DeleteLoginProfile(*iam.DeleteLoginProfileInput) (*iam.DeleteLoginProfileOutput, error)
DeleteLoginProfileWithContext(aws.Context, *iam.DeleteLoginProfileInput, ...request.Option) (*iam.DeleteLoginProfileOutput, error)
DeleteLoginProfileRequest(*iam.DeleteLoginProfileInput) (*request.Request, *iam.DeleteLoginProfileOutput)
DeleteOpenIDConnectProvider(*iam.DeleteOpenIDConnectProviderInput) (*iam.DeleteOpenIDConnectProviderOutput, error)
DeleteOpenIDConnectProviderWithContext(aws.Context, *iam.DeleteOpenIDConnectProviderInput, ...request.Option) (*iam.DeleteOpenIDConnectProviderOutput, error)
DeleteOpenIDConnectProviderRequest(*iam.DeleteOpenIDConnectProviderInput) (*request.Request, *iam.DeleteOpenIDConnectProviderOutput)
DeletePolicy(*iam.DeletePolicyInput) (*iam.DeletePolicyOutput, error)
DeletePolicyWithContext(aws.Context, *iam.DeletePolicyInput, ...request.Option) (*iam.DeletePolicyOutput, error)
DeletePolicyRequest(*iam.DeletePolicyInput) (*request.Request, *iam.DeletePolicyOutput)
DeletePolicyVersion(*iam.DeletePolicyVersionInput) (*iam.DeletePolicyVersionOutput, error)
DeletePolicyVersionWithContext(aws.Context, *iam.DeletePolicyVersionInput, ...request.Option) (*iam.DeletePolicyVersionOutput, error)
DeletePolicyVersionRequest(*iam.DeletePolicyVersionInput) (*request.Request, *iam.DeletePolicyVersionOutput)
DeleteRole(*iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error)
DeleteRoleWithContext(aws.Context, *iam.DeleteRoleInput, ...request.Option) (*iam.DeleteRoleOutput, error)
DeleteRoleRequest(*iam.DeleteRoleInput) (*request.Request, *iam.DeleteRoleOutput)
DeleteRolePolicy(*iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error)
DeleteRolePolicyWithContext(aws.Context, *iam.DeleteRolePolicyInput, ...request.Option) (*iam.DeleteRolePolicyOutput, error)
DeleteRolePolicyRequest(*iam.DeleteRolePolicyInput) (*request.Request, *iam.DeleteRolePolicyOutput)
DeleteSAMLProvider(*iam.DeleteSAMLProviderInput) (*iam.DeleteSAMLProviderOutput, error)
DeleteSAMLProviderWithContext(aws.Context, *iam.DeleteSAMLProviderInput, ...request.Option) (*iam.DeleteSAMLProviderOutput, error)
DeleteSAMLProviderRequest(*iam.DeleteSAMLProviderInput) (*request.Request, *iam.DeleteSAMLProviderOutput)
DeleteSSHPublicKey(*iam.DeleteSSHPublicKeyInput) (*iam.DeleteSSHPublicKeyOutput, error)
DeleteSSHPublicKeyWithContext(aws.Context, *iam.DeleteSSHPublicKeyInput, ...request.Option) (*iam.DeleteSSHPublicKeyOutput, error)
DeleteSSHPublicKeyRequest(*iam.DeleteSSHPublicKeyInput) (*request.Request, *iam.DeleteSSHPublicKeyOutput)
DeleteServerCertificate(*iam.DeleteServerCertificateInput) (*iam.DeleteServerCertificateOutput, error)
DeleteServerCertificateWithContext(aws.Context, *iam.DeleteServerCertificateInput, ...request.Option) (*iam.DeleteServerCertificateOutput, error)
DeleteServerCertificateRequest(*iam.DeleteServerCertificateInput) (*request.Request, *iam.DeleteServerCertificateOutput)
DeleteServiceLinkedRole(*iam.DeleteServiceLinkedRoleInput) (*iam.DeleteServiceLinkedRoleOutput, error)
DeleteServiceLinkedRoleWithContext(aws.Context, *iam.DeleteServiceLinkedRoleInput, ...request.Option) (*iam.DeleteServiceLinkedRoleOutput, error)
DeleteServiceLinkedRoleRequest(*iam.DeleteServiceLinkedRoleInput) (*request.Request, *iam.DeleteServiceLinkedRoleOutput)
DeleteServiceSpecificCredential(*iam.DeleteServiceSpecificCredentialInput) (*iam.DeleteServiceSpecificCredentialOutput, error)
DeleteServiceSpecificCredentialWithContext(aws.Context, *iam.DeleteServiceSpecificCredentialInput, ...request.Option) (*iam.DeleteServiceSpecificCredentialOutput, error)
DeleteServiceSpecificCredentialRequest(*iam.DeleteServiceSpecificCredentialInput) (*request.Request, *iam.DeleteServiceSpecificCredentialOutput)
DeleteSigningCertificate(*iam.DeleteSigningCertificateInput) (*iam.DeleteSigningCertificateOutput, error)
DeleteSigningCertificateWithContext(aws.Context, *iam.DeleteSigningCertificateInput, ...request.Option) (*iam.DeleteSigningCertificateOutput, error)
DeleteSigningCertificateRequest(*iam.DeleteSigningCertificateInput) (*request.Request, *iam.DeleteSigningCertificateOutput)
DeleteUser(*iam.DeleteUserInput) (*iam.DeleteUserOutput, error)
DeleteUserWithContext(aws.Context, *iam.DeleteUserInput, ...request.Option) (*iam.DeleteUserOutput, error)
DeleteUserRequest(*iam.DeleteUserInput) (*request.Request, *iam.DeleteUserOutput)
DeleteUserPolicy(*iam.DeleteUserPolicyInput) (*iam.DeleteUserPolicyOutput, error)
DeleteUserPolicyWithContext(aws.Context, *iam.DeleteUserPolicyInput, ...request.Option) (*iam.DeleteUserPolicyOutput, error)
DeleteUserPolicyRequest(*iam.DeleteUserPolicyInput) (*request.Request, *iam.DeleteUserPolicyOutput)
DeleteVirtualMFADevice(*iam.DeleteVirtualMFADeviceInput) (*iam.DeleteVirtualMFADeviceOutput, error)
DeleteVirtualMFADeviceWithContext(aws.Context, *iam.DeleteVirtualMFADeviceInput, ...request.Option) (*iam.DeleteVirtualMFADeviceOutput, error)
DeleteVirtualMFADeviceRequest(*iam.DeleteVirtualMFADeviceInput) (*request.Request, *iam.DeleteVirtualMFADeviceOutput)
DetachGroupPolicy(*iam.DetachGroupPolicyInput) (*iam.DetachGroupPolicyOutput, error)
DetachGroupPolicyWithContext(aws.Context, *iam.DetachGroupPolicyInput, ...request.Option) (*iam.DetachGroupPolicyOutput, error)
DetachGroupPolicyRequest(*iam.DetachGroupPolicyInput) (*request.Request, *iam.DetachGroupPolicyOutput)
DetachRolePolicy(*iam.DetachRolePolicyInput) (*iam.DetachRolePolicyOutput, error)
DetachRolePolicyWithContext(aws.Context, *iam.DetachRolePolicyInput, ...request.Option) (*iam.DetachRolePolicyOutput, error)
DetachRolePolicyRequest(*iam.DetachRolePolicyInput) (*request.Request, *iam.DetachRolePolicyOutput)
DetachUserPolicy(*iam.DetachUserPolicyInput) (*iam.DetachUserPolicyOutput, error)
DetachUserPolicyWithContext(aws.Context, *iam.DetachUserPolicyInput, ...request.Option) (*iam.DetachUserPolicyOutput, error)
DetachUserPolicyRequest(*iam.DetachUserPolicyInput) (*request.Request, *iam.DetachUserPolicyOutput)
EnableMFADevice(*iam.EnableMFADeviceInput) (*iam.EnableMFADeviceOutput, error)
EnableMFADeviceWithContext(aws.Context, *iam.EnableMFADeviceInput, ...request.Option) (*iam.EnableMFADeviceOutput, error)
EnableMFADeviceRequest(*iam.EnableMFADeviceInput) (*request.Request, *iam.EnableMFADeviceOutput)
GenerateCredentialReport(*iam.GenerateCredentialReportInput) (*iam.GenerateCredentialReportOutput, error)
GenerateCredentialReportWithContext(aws.Context, *iam.GenerateCredentialReportInput, ...request.Option) (*iam.GenerateCredentialReportOutput, error)
GenerateCredentialReportRequest(*iam.GenerateCredentialReportInput) (*request.Request, *iam.GenerateCredentialReportOutput)
GetAccessKeyLastUsed(*iam.GetAccessKeyLastUsedInput) (*iam.GetAccessKeyLastUsedOutput, error)
GetAccessKeyLastUsedWithContext(aws.Context, *iam.GetAccessKeyLastUsedInput, ...request.Option) (*iam.GetAccessKeyLastUsedOutput, error)
GetAccessKeyLastUsedRequest(*iam.GetAccessKeyLastUsedInput) (*request.Request, *iam.GetAccessKeyLastUsedOutput)
GetAccountAuthorizationDetails(*iam.GetAccountAuthorizationDetailsInput) (*iam.GetAccountAuthorizationDetailsOutput, error)
GetAccountAuthorizationDetailsWithContext(aws.Context, *iam.GetAccountAuthorizationDetailsInput, ...request.Option) (*iam.GetAccountAuthorizationDetailsOutput, error)
GetAccountAuthorizationDetailsRequest(*iam.GetAccountAuthorizationDetailsInput) (*request.Request, *iam.GetAccountAuthorizationDetailsOutput)
GetAccountAuthorizationDetailsPages(*iam.GetAccountAuthorizationDetailsInput, func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool) error
GetAccountAuthorizationDetailsPagesWithContext(aws.Context, *iam.GetAccountAuthorizationDetailsInput, func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool, ...request.Option) error
GetAccountPasswordPolicy(*iam.GetAccountPasswordPolicyInput) (*iam.GetAccountPasswordPolicyOutput, error)
GetAccountPasswordPolicyWithContext(aws.Context, *iam.GetAccountPasswordPolicyInput, ...request.Option) (*iam.GetAccountPasswordPolicyOutput, error)
GetAccountPasswordPolicyRequest(*iam.GetAccountPasswordPolicyInput) (*request.Request, *iam.GetAccountPasswordPolicyOutput)
GetAccountSummary(*iam.GetAccountSummaryInput) (*iam.GetAccountSummaryOutput, error)
GetAccountSummaryWithContext(aws.Context, *iam.GetAccountSummaryInput, ...request.Option) (*iam.GetAccountSummaryOutput, error)
GetAccountSummaryRequest(*iam.GetAccountSummaryInput) (*request.Request, *iam.GetAccountSummaryOutput)
GetContextKeysForCustomPolicy(*iam.GetContextKeysForCustomPolicyInput) (*iam.GetContextKeysForPolicyResponse, error)
GetContextKeysForCustomPolicyWithContext(aws.Context, *iam.GetContextKeysForCustomPolicyInput, ...request.Option) (*iam.GetContextKeysForPolicyResponse, error)
GetContextKeysForCustomPolicyRequest(*iam.GetContextKeysForCustomPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse)
GetContextKeysForPrincipalPolicy(*iam.GetContextKeysForPrincipalPolicyInput) (*iam.GetContextKeysForPolicyResponse, error)
GetContextKeysForPrincipalPolicyWithContext(aws.Context, *iam.GetContextKeysForPrincipalPolicyInput, ...request.Option) (*iam.GetContextKeysForPolicyResponse, error)
GetContextKeysForPrincipalPolicyRequest(*iam.GetContextKeysForPrincipalPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse)
GetCredentialReport(*iam.GetCredentialReportInput) (*iam.GetCredentialReportOutput, error)
GetCredentialReportWithContext(aws.Context, *iam.GetCredentialReportInput, ...request.Option) (*iam.GetCredentialReportOutput, error)
GetCredentialReportRequest(*iam.GetCredentialReportInput) (*request.Request, *iam.GetCredentialReportOutput)
GetGroup(*iam.GetGroupInput) (*iam.GetGroupOutput, error)
GetGroupWithContext(aws.Context, *iam.GetGroupInput, ...request.Option) (*iam.GetGroupOutput, error)
GetGroupRequest(*iam.GetGroupInput) (*request.Request, *iam.GetGroupOutput)
GetGroupPages(*iam.GetGroupInput, func(*iam.GetGroupOutput, bool) bool) error
GetGroupPagesWithContext(aws.Context, *iam.GetGroupInput, func(*iam.GetGroupOutput, bool) bool, ...request.Option) error
GetGroupPolicy(*iam.GetGroupPolicyInput) (*iam.GetGroupPolicyOutput, error)
GetGroupPolicyWithContext(aws.Context, *iam.GetGroupPolicyInput, ...request.Option) (*iam.GetGroupPolicyOutput, error)
GetGroupPolicyRequest(*iam.GetGroupPolicyInput) (*request.Request, *iam.GetGroupPolicyOutput)
GetInstanceProfile(*iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error)
GetInstanceProfileWithContext(aws.Context, *iam.GetInstanceProfileInput, ...request.Option) (*iam.GetInstanceProfileOutput, error)
GetInstanceProfileRequest(*iam.GetInstanceProfileInput) (*request.Request, *iam.GetInstanceProfileOutput)
GetLoginProfile(*iam.GetLoginProfileInput) (*iam.GetLoginProfileOutput, error)
GetLoginProfileWithContext(aws.Context, *iam.GetLoginProfileInput, ...request.Option) (*iam.GetLoginProfileOutput, error)
GetLoginProfileRequest(*iam.GetLoginProfileInput) (*request.Request, *iam.GetLoginProfileOutput)
GetOpenIDConnectProvider(*iam.GetOpenIDConnectProviderInput) (*iam.GetOpenIDConnectProviderOutput, error)
GetOpenIDConnectProviderWithContext(aws.Context, *iam.GetOpenIDConnectProviderInput, ...request.Option) (*iam.GetOpenIDConnectProviderOutput, error)
GetOpenIDConnectProviderRequest(*iam.GetOpenIDConnectProviderInput) (*request.Request, *iam.GetOpenIDConnectProviderOutput)
GetPolicy(*iam.GetPolicyInput) (*iam.GetPolicyOutput, error)
GetPolicyWithContext(aws.Context, *iam.GetPolicyInput, ...request.Option) (*iam.GetPolicyOutput, error)
GetPolicyRequest(*iam.GetPolicyInput) (*request.Request, *iam.GetPolicyOutput)
GetPolicyVersion(*iam.GetPolicyVersionInput) (*iam.GetPolicyVersionOutput, error)
GetPolicyVersionWithContext(aws.Context, *iam.GetPolicyVersionInput, ...request.Option) (*iam.GetPolicyVersionOutput, error)
GetPolicyVersionRequest(*iam.GetPolicyVersionInput) (*request.Request, *iam.GetPolicyVersionOutput)
GetRole(*iam.GetRoleInput) (*iam.GetRoleOutput, error)
GetRoleWithContext(aws.Context, *iam.GetRoleInput, ...request.Option) (*iam.GetRoleOutput, error)
GetRoleRequest(*iam.GetRoleInput) (*request.Request, *iam.GetRoleOutput)
GetRolePolicy(*iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error)
GetRolePolicyWithContext(aws.Context, *iam.GetRolePolicyInput, ...request.Option) (*iam.GetRolePolicyOutput, error)
GetRolePolicyRequest(*iam.GetRolePolicyInput) (*request.Request, *iam.GetRolePolicyOutput)
GetSAMLProvider(*iam.GetSAMLProviderInput) (*iam.GetSAMLProviderOutput, error)
GetSAMLProviderWithContext(aws.Context, *iam.GetSAMLProviderInput, ...request.Option) (*iam.GetSAMLProviderOutput, error)
GetSAMLProviderRequest(*iam.GetSAMLProviderInput) (*request.Request, *iam.GetSAMLProviderOutput)
GetSSHPublicKey(*iam.GetSSHPublicKeyInput) (*iam.GetSSHPublicKeyOutput, error)
GetSSHPublicKeyWithContext(aws.Context, *iam.GetSSHPublicKeyInput, ...request.Option) (*iam.GetSSHPublicKeyOutput, error)
GetSSHPublicKeyRequest(*iam.GetSSHPublicKeyInput) (*request.Request, *iam.GetSSHPublicKeyOutput)
GetServerCertificate(*iam.GetServerCertificateInput) (*iam.GetServerCertificateOutput, error)
GetServerCertificateWithContext(aws.Context, *iam.GetServerCertificateInput, ...request.Option) (*iam.GetServerCertificateOutput, error)
GetServerCertificateRequest(*iam.GetServerCertificateInput) (*request.Request, *iam.GetServerCertificateOutput)
GetServiceLinkedRoleDeletionStatus(*iam.GetServiceLinkedRoleDeletionStatusInput) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error)
GetServiceLinkedRoleDeletionStatusWithContext(aws.Context, *iam.GetServiceLinkedRoleDeletionStatusInput, ...request.Option) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error)
GetServiceLinkedRoleDeletionStatusRequest(*iam.GetServiceLinkedRoleDeletionStatusInput) (*request.Request, *iam.GetServiceLinkedRoleDeletionStatusOutput)
GetUser(*iam.GetUserInput) (*iam.GetUserOutput, error)
GetUserWithContext(aws.Context, *iam.GetUserInput, ...request.Option) (*iam.GetUserOutput, error)
GetUserRequest(*iam.GetUserInput) (*request.Request, *iam.GetUserOutput)
GetUserPolicy(*iam.GetUserPolicyInput) (*iam.GetUserPolicyOutput, error)
GetUserPolicyWithContext(aws.Context, *iam.GetUserPolicyInput, ...request.Option) (*iam.GetUserPolicyOutput, error)
GetUserPolicyRequest(*iam.GetUserPolicyInput) (*request.Request, *iam.GetUserPolicyOutput)
ListAccessKeys(*iam.ListAccessKeysInput) (*iam.ListAccessKeysOutput, error)
ListAccessKeysWithContext(aws.Context, *iam.ListAccessKeysInput, ...request.Option) (*iam.ListAccessKeysOutput, error)
ListAccessKeysRequest(*iam.ListAccessKeysInput) (*request.Request, *iam.ListAccessKeysOutput)
ListAccessKeysPages(*iam.ListAccessKeysInput, func(*iam.ListAccessKeysOutput, bool) bool) error
ListAccessKeysPagesWithContext(aws.Context, *iam.ListAccessKeysInput, func(*iam.ListAccessKeysOutput, bool) bool, ...request.Option) error
ListAccountAliases(*iam.ListAccountAliasesInput) (*iam.ListAccountAliasesOutput, error)
ListAccountAliasesWithContext(aws.Context, *iam.ListAccountAliasesInput, ...request.Option) (*iam.ListAccountAliasesOutput, error)
ListAccountAliasesRequest(*iam.ListAccountAliasesInput) (*request.Request, *iam.ListAccountAliasesOutput)
ListAccountAliasesPages(*iam.ListAccountAliasesInput, func(*iam.ListAccountAliasesOutput, bool) bool) error
ListAccountAliasesPagesWithContext(aws.Context, *iam.ListAccountAliasesInput, func(*iam.ListAccountAliasesOutput, bool) bool, ...request.Option) error
ListAttachedGroupPolicies(*iam.ListAttachedGroupPoliciesInput) (*iam.ListAttachedGroupPoliciesOutput, error)
ListAttachedGroupPoliciesWithContext(aws.Context, *iam.ListAttachedGroupPoliciesInput, ...request.Option) (*iam.ListAttachedGroupPoliciesOutput, error)
ListAttachedGroupPoliciesRequest(*iam.ListAttachedGroupPoliciesInput) (*request.Request, *iam.ListAttachedGroupPoliciesOutput)
ListAttachedGroupPoliciesPages(*iam.ListAttachedGroupPoliciesInput, func(*iam.ListAttachedGroupPoliciesOutput, bool) bool) error
ListAttachedGroupPoliciesPagesWithContext(aws.Context, *iam.ListAttachedGroupPoliciesInput, func(*iam.ListAttachedGroupPoliciesOutput, bool) bool, ...request.Option) error
ListAttachedRolePolicies(*iam.ListAttachedRolePoliciesInput) (*iam.ListAttachedRolePoliciesOutput, error)
ListAttachedRolePoliciesWithContext(aws.Context, *iam.ListAttachedRolePoliciesInput, ...request.Option) (*iam.ListAttachedRolePoliciesOutput, error)
ListAttachedRolePoliciesRequest(*iam.ListAttachedRolePoliciesInput) (*request.Request, *iam.ListAttachedRolePoliciesOutput)
ListAttachedRolePoliciesPages(*iam.ListAttachedRolePoliciesInput, func(*iam.ListAttachedRolePoliciesOutput, bool) bool) error
ListAttachedRolePoliciesPagesWithContext(aws.Context, *iam.ListAttachedRolePoliciesInput, func(*iam.ListAttachedRolePoliciesOutput, bool) bool, ...request.Option) error
ListAttachedUserPolicies(*iam.ListAttachedUserPoliciesInput) (*iam.ListAttachedUserPoliciesOutput, error)
ListAttachedUserPoliciesWithContext(aws.Context, *iam.ListAttachedUserPoliciesInput, ...request.Option) (*iam.ListAttachedUserPoliciesOutput, error)
ListAttachedUserPoliciesRequest(*iam.ListAttachedUserPoliciesInput) (*request.Request, *iam.ListAttachedUserPoliciesOutput)
ListAttachedUserPoliciesPages(*iam.ListAttachedUserPoliciesInput, func(*iam.ListAttachedUserPoliciesOutput, bool) bool) error
ListAttachedUserPoliciesPagesWithContext(aws.Context, *iam.ListAttachedUserPoliciesInput, func(*iam.ListAttachedUserPoliciesOutput, bool) bool, ...request.Option) error
ListEntitiesForPolicy(*iam.ListEntitiesForPolicyInput) (*iam.ListEntitiesForPolicyOutput, error)
ListEntitiesForPolicyWithContext(aws.Context, *iam.ListEntitiesForPolicyInput, ...request.Option) (*iam.ListEntitiesForPolicyOutput, error)
ListEntitiesForPolicyRequest(*iam.ListEntitiesForPolicyInput) (*request.Request, *iam.ListEntitiesForPolicyOutput)
ListEntitiesForPolicyPages(*iam.ListEntitiesForPolicyInput, func(*iam.ListEntitiesForPolicyOutput, bool) bool) error
ListEntitiesForPolicyPagesWithContext(aws.Context, *iam.ListEntitiesForPolicyInput, func(*iam.ListEntitiesForPolicyOutput, bool) bool, ...request.Option) error
ListGroupPolicies(*iam.ListGroupPoliciesInput) (*iam.ListGroupPoliciesOutput, error)
ListGroupPoliciesWithContext(aws.Context, *iam.ListGroupPoliciesInput, ...request.Option) (*iam.ListGroupPoliciesOutput, error)
ListGroupPoliciesRequest(*iam.ListGroupPoliciesInput) (*request.Request, *iam.ListGroupPoliciesOutput)
ListGroupPoliciesPages(*iam.ListGroupPoliciesInput, func(*iam.ListGroupPoliciesOutput, bool) bool) error
ListGroupPoliciesPagesWithContext(aws.Context, *iam.ListGroupPoliciesInput, func(*iam.ListGroupPoliciesOutput, bool) bool, ...request.Option) error
ListGroups(*iam.ListGroupsInput) (*iam.ListGroupsOutput, error)
ListGroupsWithContext(aws.Context, *iam.ListGroupsInput, ...request.Option) (*iam.ListGroupsOutput, error)
ListGroupsRequest(*iam.ListGroupsInput) (*request.Request, *iam.ListGroupsOutput)
ListGroupsPages(*iam.ListGroupsInput, func(*iam.ListGroupsOutput, bool) bool) error
ListGroupsPagesWithContext(aws.Context, *iam.ListGroupsInput, func(*iam.ListGroupsOutput, bool) bool, ...request.Option) error
ListGroupsForUser(*iam.ListGroupsForUserInput) (*iam.ListGroupsForUserOutput, error)
ListGroupsForUserWithContext(aws.Context, *iam.ListGroupsForUserInput, ...request.Option) (*iam.ListGroupsForUserOutput, error)
ListGroupsForUserRequest(*iam.ListGroupsForUserInput) (*request.Request, *iam.ListGroupsForUserOutput)
ListGroupsForUserPages(*iam.ListGroupsForUserInput, func(*iam.ListGroupsForUserOutput, bool) bool) error
ListGroupsForUserPagesWithContext(aws.Context, *iam.ListGroupsForUserInput, func(*iam.ListGroupsForUserOutput, bool) bool, ...request.Option) error
ListInstanceProfiles(*iam.ListInstanceProfilesInput) (*iam.ListInstanceProfilesOutput, error)
ListInstanceProfilesWithContext(aws.Context, *iam.ListInstanceProfilesInput, ...request.Option) (*iam.ListInstanceProfilesOutput, error)
ListInstanceProfilesRequest(*iam.ListInstanceProfilesInput) (*request.Request, *iam.ListInstanceProfilesOutput)
ListInstanceProfilesPages(*iam.ListInstanceProfilesInput, func(*iam.ListInstanceProfilesOutput, bool) bool) error
ListInstanceProfilesPagesWithContext(aws.Context, *iam.ListInstanceProfilesInput, func(*iam.ListInstanceProfilesOutput, bool) bool, ...request.Option) error
ListInstanceProfilesForRole(*iam.ListInstanceProfilesForRoleInput) (*iam.ListInstanceProfilesForRoleOutput, error)
ListInstanceProfilesForRoleWithContext(aws.Context, *iam.ListInstanceProfilesForRoleInput, ...request.Option) (*iam.ListInstanceProfilesForRoleOutput, error)
ListInstanceProfilesForRoleRequest(*iam.ListInstanceProfilesForRoleInput) (*request.Request, *iam.ListInstanceProfilesForRoleOutput)
ListInstanceProfilesForRolePages(*iam.ListInstanceProfilesForRoleInput, func(*iam.ListInstanceProfilesForRoleOutput, bool) bool) error
ListInstanceProfilesForRolePagesWithContext(aws.Context, *iam.ListInstanceProfilesForRoleInput, func(*iam.ListInstanceProfilesForRoleOutput, bool) bool, ...request.Option) error
ListMFADevices(*iam.ListMFADevicesInput) (*iam.ListMFADevicesOutput, error)
ListMFADevicesWithContext(aws.Context, *iam.ListMFADevicesInput, ...request.Option) (*iam.ListMFADevicesOutput, error)
ListMFADevicesRequest(*iam.ListMFADevicesInput) (*request.Request, *iam.ListMFADevicesOutput)
ListMFADevicesPages(*iam.ListMFADevicesInput, func(*iam.ListMFADevicesOutput, bool) bool) error
ListMFADevicesPagesWithContext(aws.Context, *iam.ListMFADevicesInput, func(*iam.ListMFADevicesOutput, bool) bool, ...request.Option) error
ListOpenIDConnectProviders(*iam.ListOpenIDConnectProvidersInput) (*iam.ListOpenIDConnectProvidersOutput, error)
ListOpenIDConnectProvidersWithContext(aws.Context, *iam.ListOpenIDConnectProvidersInput, ...request.Option) (*iam.ListOpenIDConnectProvidersOutput, error)
ListOpenIDConnectProvidersRequest(*iam.ListOpenIDConnectProvidersInput) (*request.Request, *iam.ListOpenIDConnectProvidersOutput)
ListPolicies(*iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error)
ListPoliciesWithContext(aws.Context, *iam.ListPoliciesInput, ...request.Option) (*iam.ListPoliciesOutput, error)
ListPoliciesRequest(*iam.ListPoliciesInput) (*request.Request, *iam.ListPoliciesOutput)
ListPoliciesPages(*iam.ListPoliciesInput, func(*iam.ListPoliciesOutput, bool) bool) error
ListPoliciesPagesWithContext(aws.Context, *iam.ListPoliciesInput, func(*iam.ListPoliciesOutput, bool) bool, ...request.Option) error
ListPolicyVersions(*iam.ListPolicyVersionsInput) (*iam.ListPolicyVersionsOutput, error)
ListPolicyVersionsWithContext(aws.Context, *iam.ListPolicyVersionsInput, ...request.Option) (*iam.ListPolicyVersionsOutput, error)
ListPolicyVersionsRequest(*iam.ListPolicyVersionsInput) (*request.Request, *iam.ListPolicyVersionsOutput)
ListPolicyVersionsPages(*iam.ListPolicyVersionsInput, func(*iam.ListPolicyVersionsOutput, bool) bool) error
ListPolicyVersionsPagesWithContext(aws.Context, *iam.ListPolicyVersionsInput, func(*iam.ListPolicyVersionsOutput, bool) bool, ...request.Option) error
ListRolePolicies(*iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error)
ListRolePoliciesWithContext(aws.Context, *iam.ListRolePoliciesInput, ...request.Option) (*iam.ListRolePoliciesOutput, error)
ListRolePoliciesRequest(*iam.ListRolePoliciesInput) (*request.Request, *iam.ListRolePoliciesOutput)
ListRolePoliciesPages(*iam.ListRolePoliciesInput, func(*iam.ListRolePoliciesOutput, bool) bool) error
ListRolePoliciesPagesWithContext(aws.Context, *iam.ListRolePoliciesInput, func(*iam.ListRolePoliciesOutput, bool) bool, ...request.Option) error
ListRoles(*iam.ListRolesInput) (*iam.ListRolesOutput, error)
ListRolesWithContext(aws.Context, *iam.ListRolesInput, ...request.Option) (*iam.ListRolesOutput, error)
ListRolesRequest(*iam.ListRolesInput) (*request.Request, *iam.ListRolesOutput)
ListRolesPages(*iam.ListRolesInput, func(*iam.ListRolesOutput, bool) bool) error
ListRolesPagesWithContext(aws.Context, *iam.ListRolesInput, func(*iam.ListRolesOutput, bool) bool, ...request.Option) error
ListSAMLProviders(*iam.ListSAMLProvidersInput) (*iam.ListSAMLProvidersOutput, error)
ListSAMLProvidersWithContext(aws.Context, *iam.ListSAMLProvidersInput, ...request.Option) (*iam.ListSAMLProvidersOutput, error)
ListSAMLProvidersRequest(*iam.ListSAMLProvidersInput) (*request.Request, *iam.ListSAMLProvidersOutput)
ListSSHPublicKeys(*iam.ListSSHPublicKeysInput) (*iam.ListSSHPublicKeysOutput, error)
ListSSHPublicKeysWithContext(aws.Context, *iam.ListSSHPublicKeysInput, ...request.Option) (*iam.ListSSHPublicKeysOutput, error)
ListSSHPublicKeysRequest(*iam.ListSSHPublicKeysInput) (*request.Request, *iam.ListSSHPublicKeysOutput)
ListSSHPublicKeysPages(*iam.ListSSHPublicKeysInput, func(*iam.ListSSHPublicKeysOutput, bool) bool) error
ListSSHPublicKeysPagesWithContext(aws.Context, *iam.ListSSHPublicKeysInput, func(*iam.ListSSHPublicKeysOutput, bool) bool, ...request.Option) error
ListServerCertificates(*iam.ListServerCertificatesInput) (*iam.ListServerCertificatesOutput, error)
ListServerCertificatesWithContext(aws.Context, *iam.ListServerCertificatesInput, ...request.Option) (*iam.ListServerCertificatesOutput, error)
ListServerCertificatesRequest(*iam.ListServerCertificatesInput) (*request.Request, *iam.ListServerCertificatesOutput)
ListServerCertificatesPages(*iam.ListServerCertificatesInput, func(*iam.ListServerCertificatesOutput, bool) bool) error
ListServerCertificatesPagesWithContext(aws.Context, *iam.ListServerCertificatesInput, func(*iam.ListServerCertificatesOutput, bool) bool, ...request.Option) error
ListServiceSpecificCredentials(*iam.ListServiceSpecificCredentialsInput) (*iam.ListServiceSpecificCredentialsOutput, error)
ListServiceSpecificCredentialsWithContext(aws.Context, *iam.ListServiceSpecificCredentialsInput, ...request.Option) (*iam.ListServiceSpecificCredentialsOutput, error)
ListServiceSpecificCredentialsRequest(*iam.ListServiceSpecificCredentialsInput) (*request.Request, *iam.ListServiceSpecificCredentialsOutput)
ListSigningCertificates(*iam.ListSigningCertificatesInput) (*iam.ListSigningCertificatesOutput, error)
ListSigningCertificatesWithContext(aws.Context, *iam.ListSigningCertificatesInput, ...request.Option) (*iam.ListSigningCertificatesOutput, error)
ListSigningCertificatesRequest(*iam.ListSigningCertificatesInput) (*request.Request, *iam.ListSigningCertificatesOutput)
ListSigningCertificatesPages(*iam.ListSigningCertificatesInput, func(*iam.ListSigningCertificatesOutput, bool) bool) error
ListSigningCertificatesPagesWithContext(aws.Context, *iam.ListSigningCertificatesInput, func(*iam.ListSigningCertificatesOutput, bool) bool, ...request.Option) error
ListUserPolicies(*iam.ListUserPoliciesInput) (*iam.ListUserPoliciesOutput, error)
ListUserPoliciesWithContext(aws.Context, *iam.ListUserPoliciesInput, ...request.Option) (*iam.ListUserPoliciesOutput, error)
ListUserPoliciesRequest(*iam.ListUserPoliciesInput) (*request.Request, *iam.ListUserPoliciesOutput)
ListUserPoliciesPages(*iam.ListUserPoliciesInput, func(*iam.ListUserPoliciesOutput, bool) bool) error
ListUserPoliciesPagesWithContext(aws.Context, *iam.ListUserPoliciesInput, func(*iam.ListUserPoliciesOutput, bool) bool, ...request.Option) error
ListUsers(*iam.ListUsersInput) (*iam.ListUsersOutput, error)
ListUsersWithContext(aws.Context, *iam.ListUsersInput, ...request.Option) (*iam.ListUsersOutput, error)
ListUsersRequest(*iam.ListUsersInput) (*request.Request, *iam.ListUsersOutput)
ListUsersPages(*iam.ListUsersInput, func(*iam.ListUsersOutput, bool) bool) error
ListUsersPagesWithContext(aws.Context, *iam.ListUsersInput, func(*iam.ListUsersOutput, bool) bool, ...request.Option) error
ListVirtualMFADevices(*iam.ListVirtualMFADevicesInput) (*iam.ListVirtualMFADevicesOutput, error)
ListVirtualMFADevicesWithContext(aws.Context, *iam.ListVirtualMFADevicesInput, ...request.Option) (*iam.ListVirtualMFADevicesOutput, error)
ListVirtualMFADevicesRequest(*iam.ListVirtualMFADevicesInput) (*request.Request, *iam.ListVirtualMFADevicesOutput)
ListVirtualMFADevicesPages(*iam.ListVirtualMFADevicesInput, func(*iam.ListVirtualMFADevicesOutput, bool) bool) error
ListVirtualMFADevicesPagesWithContext(aws.Context, *iam.ListVirtualMFADevicesInput, func(*iam.ListVirtualMFADevicesOutput, bool) bool, ...request.Option) error
PutGroupPolicy(*iam.PutGroupPolicyInput) (*iam.PutGroupPolicyOutput, error)
PutGroupPolicyWithContext(aws.Context, *iam.PutGroupPolicyInput, ...request.Option) (*iam.PutGroupPolicyOutput, error)
PutGroupPolicyRequest(*iam.PutGroupPolicyInput) (*request.Request, *iam.PutGroupPolicyOutput)
PutRolePolicy(*iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error)
PutRolePolicyWithContext(aws.Context, *iam.PutRolePolicyInput, ...request.Option) (*iam.PutRolePolicyOutput, error)
PutRolePolicyRequest(*iam.PutRolePolicyInput) (*request.Request, *iam.PutRolePolicyOutput)
PutUserPolicy(*iam.PutUserPolicyInput) (*iam.PutUserPolicyOutput, error)
PutUserPolicyWithContext(aws.Context, *iam.PutUserPolicyInput, ...request.Option) (*iam.PutUserPolicyOutput, error)
PutUserPolicyRequest(*iam.PutUserPolicyInput) (*request.Request, *iam.PutUserPolicyOutput)
RemoveClientIDFromOpenIDConnectProvider(*iam.RemoveClientIDFromOpenIDConnectProviderInput) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error)
RemoveClientIDFromOpenIDConnectProviderWithContext(aws.Context, *iam.RemoveClientIDFromOpenIDConnectProviderInput, ...request.Option) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error)
RemoveClientIDFromOpenIDConnectProviderRequest(*iam.RemoveClientIDFromOpenIDConnectProviderInput) (*request.Request, *iam.RemoveClientIDFromOpenIDConnectProviderOutput)
RemoveRoleFromInstanceProfile(*iam.RemoveRoleFromInstanceProfileInput) (*iam.RemoveRoleFromInstanceProfileOutput, error)
RemoveRoleFromInstanceProfileWithContext(aws.Context, *iam.RemoveRoleFromInstanceProfileInput, ...request.Option) (*iam.RemoveRoleFromInstanceProfileOutput, error)
RemoveRoleFromInstanceProfileRequest(*iam.RemoveRoleFromInstanceProfileInput) (*request.Request, *iam.RemoveRoleFromInstanceProfileOutput)
RemoveUserFromGroup(*iam.RemoveUserFromGroupInput) (*iam.RemoveUserFromGroupOutput, error)
RemoveUserFromGroupWithContext(aws.Context, *iam.RemoveUserFromGroupInput, ...request.Option) (*iam.RemoveUserFromGroupOutput, error)
RemoveUserFromGroupRequest(*iam.RemoveUserFromGroupInput) (*request.Request, *iam.RemoveUserFromGroupOutput)
ResetServiceSpecificCredential(*iam.ResetServiceSpecificCredentialInput) (*iam.ResetServiceSpecificCredentialOutput, error)
ResetServiceSpecificCredentialWithContext(aws.Context, *iam.ResetServiceSpecificCredentialInput, ...request.Option) (*iam.ResetServiceSpecificCredentialOutput, error)
ResetServiceSpecificCredentialRequest(*iam.ResetServiceSpecificCredentialInput) (*request.Request, *iam.ResetServiceSpecificCredentialOutput)
ResyncMFADevice(*iam.ResyncMFADeviceInput) (*iam.ResyncMFADeviceOutput, error)
ResyncMFADeviceWithContext(aws.Context, *iam.ResyncMFADeviceInput, ...request.Option) (*iam.ResyncMFADeviceOutput, error)
ResyncMFADeviceRequest(*iam.ResyncMFADeviceInput) (*request.Request, *iam.ResyncMFADeviceOutput)
SetDefaultPolicyVersion(*iam.SetDefaultPolicyVersionInput) (*iam.SetDefaultPolicyVersionOutput, error)
SetDefaultPolicyVersionWithContext(aws.Context, *iam.SetDefaultPolicyVersionInput, ...request.Option) (*iam.SetDefaultPolicyVersionOutput, error)
SetDefaultPolicyVersionRequest(*iam.SetDefaultPolicyVersionInput) (*request.Request, *iam.SetDefaultPolicyVersionOutput)
SimulateCustomPolicy(*iam.SimulateCustomPolicyInput) (*iam.SimulatePolicyResponse, error)
SimulateCustomPolicyWithContext(aws.Context, *iam.SimulateCustomPolicyInput, ...request.Option) (*iam.SimulatePolicyResponse, error)
SimulateCustomPolicyRequest(*iam.SimulateCustomPolicyInput) (*request.Request, *iam.SimulatePolicyResponse)
SimulateCustomPolicyPages(*iam.SimulateCustomPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool) error
SimulateCustomPolicyPagesWithContext(aws.Context, *iam.SimulateCustomPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool, ...request.Option) error
SimulatePrincipalPolicy(*iam.SimulatePrincipalPolicyInput) (*iam.SimulatePolicyResponse, error)
SimulatePrincipalPolicyWithContext(aws.Context, *iam.SimulatePrincipalPolicyInput, ...request.Option) (*iam.SimulatePolicyResponse, error)
SimulatePrincipalPolicyRequest(*iam.SimulatePrincipalPolicyInput) (*request.Request, *iam.SimulatePolicyResponse)
SimulatePrincipalPolicyPages(*iam.SimulatePrincipalPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool) error
SimulatePrincipalPolicyPagesWithContext(aws.Context, *iam.SimulatePrincipalPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool, ...request.Option) error
UpdateAccessKey(*iam.UpdateAccessKeyInput) (*iam.UpdateAccessKeyOutput, error)
UpdateAccessKeyWithContext(aws.Context, *iam.UpdateAccessKeyInput, ...request.Option) (*iam.UpdateAccessKeyOutput, error)
UpdateAccessKeyRequest(*iam.UpdateAccessKeyInput) (*request.Request, *iam.UpdateAccessKeyOutput)
UpdateAccountPasswordPolicy(*iam.UpdateAccountPasswordPolicyInput) (*iam.UpdateAccountPasswordPolicyOutput, error)
UpdateAccountPasswordPolicyWithContext(aws.Context, *iam.UpdateAccountPasswordPolicyInput, ...request.Option) (*iam.UpdateAccountPasswordPolicyOutput, error)
UpdateAccountPasswordPolicyRequest(*iam.UpdateAccountPasswordPolicyInput) (*request.Request, *iam.UpdateAccountPasswordPolicyOutput)
UpdateAssumeRolePolicy(*iam.UpdateAssumeRolePolicyInput) (*iam.UpdateAssumeRolePolicyOutput, error)
UpdateAssumeRolePolicyWithContext(aws.Context, *iam.UpdateAssumeRolePolicyInput, ...request.Option) (*iam.UpdateAssumeRolePolicyOutput, error)
UpdateAssumeRolePolicyRequest(*iam.UpdateAssumeRolePolicyInput) (*request.Request, *iam.UpdateAssumeRolePolicyOutput)
UpdateGroup(*iam.UpdateGroupInput) (*iam.UpdateGroupOutput, error)
UpdateGroupWithContext(aws.Context, *iam.UpdateGroupInput, ...request.Option) (*iam.UpdateGroupOutput, error)
UpdateGroupRequest(*iam.UpdateGroupInput) (*request.Request, *iam.UpdateGroupOutput)
UpdateLoginProfile(*iam.UpdateLoginProfileInput) (*iam.UpdateLoginProfileOutput, error)
UpdateLoginProfileWithContext(aws.Context, *iam.UpdateLoginProfileInput, ...request.Option) (*iam.UpdateLoginProfileOutput, error)
UpdateLoginProfileRequest(*iam.UpdateLoginProfileInput) (*request.Request, *iam.UpdateLoginProfileOutput)
UpdateOpenIDConnectProviderThumbprint(*iam.UpdateOpenIDConnectProviderThumbprintInput) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error)
UpdateOpenIDConnectProviderThumbprintWithContext(aws.Context, *iam.UpdateOpenIDConnectProviderThumbprintInput, ...request.Option) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error)
UpdateOpenIDConnectProviderThumbprintRequest(*iam.UpdateOpenIDConnectProviderThumbprintInput) (*request.Request, *iam.UpdateOpenIDConnectProviderThumbprintOutput)
UpdateRoleDescription(*iam.UpdateRoleDescriptionInput) (*iam.UpdateRoleDescriptionOutput, error)
UpdateRoleDescriptionWithContext(aws.Context, *iam.UpdateRoleDescriptionInput, ...request.Option) (*iam.UpdateRoleDescriptionOutput, error)
UpdateRoleDescriptionRequest(*iam.UpdateRoleDescriptionInput) (*request.Request, *iam.UpdateRoleDescriptionOutput)
UpdateSAMLProvider(*iam.UpdateSAMLProviderInput) (*iam.UpdateSAMLProviderOutput, error)
UpdateSAMLProviderWithContext(aws.Context, *iam.UpdateSAMLProviderInput, ...request.Option) (*iam.UpdateSAMLProviderOutput, error)
UpdateSAMLProviderRequest(*iam.UpdateSAMLProviderInput) (*request.Request, *iam.UpdateSAMLProviderOutput)
UpdateSSHPublicKey(*iam.UpdateSSHPublicKeyInput) (*iam.UpdateSSHPublicKeyOutput, error)
UpdateSSHPublicKeyWithContext(aws.Context, *iam.UpdateSSHPublicKeyInput, ...request.Option) (*iam.UpdateSSHPublicKeyOutput, error)
UpdateSSHPublicKeyRequest(*iam.UpdateSSHPublicKeyInput) (*request.Request, *iam.UpdateSSHPublicKeyOutput)
UpdateServerCertificate(*iam.UpdateServerCertificateInput) (*iam.UpdateServerCertificateOutput, error)
UpdateServerCertificateWithContext(aws.Context, *iam.UpdateServerCertificateInput, ...request.Option) (*iam.UpdateServerCertificateOutput, error)
UpdateServerCertificateRequest(*iam.UpdateServerCertificateInput) (*request.Request, *iam.UpdateServerCertificateOutput)
UpdateServiceSpecificCredential(*iam.UpdateServiceSpecificCredentialInput) (*iam.UpdateServiceSpecificCredentialOutput, error)
UpdateServiceSpecificCredentialWithContext(aws.Context, *iam.UpdateServiceSpecificCredentialInput, ...request.Option) (*iam.UpdateServiceSpecificCredentialOutput, error)
UpdateServiceSpecificCredentialRequest(*iam.UpdateServiceSpecificCredentialInput) (*request.Request, *iam.UpdateServiceSpecificCredentialOutput)
UpdateSigningCertificate(*iam.UpdateSigningCertificateInput) (*iam.UpdateSigningCertificateOutput, error)
UpdateSigningCertificateWithContext(aws.Context, *iam.UpdateSigningCertificateInput, ...request.Option) (*iam.UpdateSigningCertificateOutput, error)
UpdateSigningCertificateRequest(*iam.UpdateSigningCertificateInput) (*request.Request, *iam.UpdateSigningCertificateOutput)
UpdateUser(*iam.UpdateUserInput) (*iam.UpdateUserOutput, error)
UpdateUserWithContext(aws.Context, *iam.UpdateUserInput, ...request.Option) (*iam.UpdateUserOutput, error)
UpdateUserRequest(*iam.UpdateUserInput) (*request.Request, *iam.UpdateUserOutput)
UploadSSHPublicKey(*iam.UploadSSHPublicKeyInput) (*iam.UploadSSHPublicKeyOutput, error)
UploadSSHPublicKeyWithContext(aws.Context, *iam.UploadSSHPublicKeyInput, ...request.Option) (*iam.UploadSSHPublicKeyOutput, error)
UploadSSHPublicKeyRequest(*iam.UploadSSHPublicKeyInput) (*request.Request, *iam.UploadSSHPublicKeyOutput)
UploadServerCertificate(*iam.UploadServerCertificateInput) (*iam.UploadServerCertificateOutput, error)
UploadServerCertificateWithContext(aws.Context, *iam.UploadServerCertificateInput, ...request.Option) (*iam.UploadServerCertificateOutput, error)
UploadServerCertificateRequest(*iam.UploadServerCertificateInput) (*request.Request, *iam.UploadServerCertificateOutput)
UploadSigningCertificate(*iam.UploadSigningCertificateInput) (*iam.UploadSigningCertificateOutput, error)
UploadSigningCertificateWithContext(aws.Context, *iam.UploadSigningCertificateInput, ...request.Option) (*iam.UploadSigningCertificateOutput, error)
UploadSigningCertificateRequest(*iam.UploadSigningCertificateInput) (*request.Request, *iam.UploadSigningCertificateOutput)
WaitUntilInstanceProfileExists(*iam.GetInstanceProfileInput) error
WaitUntilInstanceProfileExistsWithContext(aws.Context, *iam.GetInstanceProfileInput, ...request.WaiterOption) error
WaitUntilUserExists(*iam.GetUserInput) error
WaitUntilUserExistsWithContext(aws.Context, *iam.GetUserInput, ...request.WaiterOption) error
}
var _ IAMAPI = (*iam.IAM)(nil)

4
vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/aws/aws.go generated vendored
View File

@ -2922,7 +2922,7 @@ func (c *Cloud) findSubnets() ([]*ec2.Subnet, error) {
subnets, err := c.ec2.DescribeSubnets(request)
if err != nil {
return nil, fmt.Errorf("error describing subnets: %q", err)
return nil, fmt.Errorf("error describing subnets: %v", err)
}
var matches []*ec2.Subnet
@ -2945,7 +2945,7 @@ func (c *Cloud) findSubnets() ([]*ec2.Subnet, error) {
subnets, err = c.ec2.DescribeSubnets(request)
if err != nil {
return nil, fmt.Errorf("error describing subnets: %q", err)
return nil, fmt.Errorf("error describing subnets: %v", err)
}
return subnets, nil