Merge pull request #4569 from justinsb/mock_aws_roundtrip

Create lifecycle test against AWS mocks

Gopkg.lock

@@ -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

cloudmock/aws/mockautoscaling/BUILD.bazel

@@ -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",
     ],
 )

cloudmock/aws/mockautoscaling/api.go

@@ -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{}

cloudmock/aws/mockautoscaling/group.go

@@ -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 {
+	m.mutex.Lock()
-		if aws.StringValue(group.AutoScalingGroupName) == aws.StringValue(input.AutoScalingGroupName) {
+	defer m.mutex.Unlock()
-			for _, instanceID := range input.InstanceIds {
+
-				group.Instances = append(group.Instances, &autoscaling.Instance{InstanceId: instanceID})
+	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,
+		AvailabilityZones:    input.AvailabilityZones,
-		MaxSize:              input.MaxSize,
+		CreatedTime:          &createdTime,
-		Instances:            []*autoscaling.Instance{},
+		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)
+	for _, tag := range input.Tags {
-	return nil, nil
+		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) {
+func (m *MockAutoscaling) EnableMetricsCollection(request *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) {
-	return nil, nil
+	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 {
+		match := false
-			if aws.StringValue(group.AutoScalingGroupName) == aws.StringValue(inputGroupName) {
+
-				groups = append(groups, group)
+		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
+}

cloudmock/aws/mockautoscaling/launchconfigurations.go

@@ -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
+}

cloudmock/aws/mockautoscaling/unimplemented.go

@@ -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")
+	glog.Fatalf("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")
 	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
 }

cloudmock/aws/mockec2/BUILD.bazel

@@ -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",

cloudmock/aws/mockec2/api.go

@@ -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 map[string]*ec2.Volume
-	Volumes      []*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)
+}

cloudmock/aws/mockec2/dhcpoptions.go

@@ -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
+}

cloudmock/aws/mockec2/keypairs.go

@@ -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),

cloudmock/aws/mockec2/routetable.go

@@ -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 {
+	m.mutex.Lock()
-		glog.Fatalf("filters not implemented: %v", request.Filters)
+	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
+}

cloudmock/aws/mockec2/securitygroups.go

@@ -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) {
+func (m *MockEC2) AuthorizeSecurityGroupEgress(request *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) {
-	panic("Not implemented")
+	m.mutex.Lock()
-	return nil, nil
+	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) {
+func (m *MockEC2) AuthorizeSecurityGroupIngress(request *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) {
-	panic("Not implemented")
+	m.mutex.Lock()
-	return nil, nil
+	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
 }

cloudmock/aws/mockec2/subnets.go

@@ -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
+}

cloudmock/aws/mockec2/tags.go

@@ -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{
+			m.addTag(resourceId, tag)
-				Key:          tag.Key,
-				Value:        tag.Value,
-				ResourceId:   s(resourceId),
-				ResourceType: s(resourceType),
-			}
-			m.Tags = append(m.Tags, t)
 		}
 	}
 	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

cloudmock/aws/mockec2/unimplemented.go

@@ -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

cloudmock/aws/mockec2/volumes.go

@@ -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 {

cloudmock/aws/mockec2/vpcs.go

@@ -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
+}

cloudmock/aws/mockiam/BUILD.bazel

@@ -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",
+    ],
+)

cloudmock/aws/mockiam/api.go

@@ -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())
+}

cloudmock/aws/mockiam/iaminstanceprofile.go

@@ -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
+}

cloudmock/aws/mockiam/iamrole.go

@@ -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
+}

cloudmock/aws/mockiam/iamrolepolicy.go

@@ -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
+}

cmd/kops/BUILD.bazel

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

cmd/kops/create_cluster.go

@@ -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
 		}

cmd/kops/integration_test.go

@@ -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)
 		}

cmd/kops/lifecycle_integration_test.go

@@ -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)
+}

cmd/kops/update_cluster.go

@@ -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 := RunUpdateCluster(f, clusterName, out, options); err != nil {
-			if 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) {

hack/.packages

@@ -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

pkg/instancegroups/rollingupdate_test.go

@@ -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)
 		}
 	}
 }

pkg/pki/BUILD.bazel

@@ -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",
     ],

pkg/pki/sshkey.go

@@ -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)

pkg/resources/aws_test.go

@@ -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)
 		}
 	}

pkg/testutils/BUILD.bazel

@@ -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",

pkg/testutils/integrationtestharness.go

@@ -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"),

upup/pkg/fi/cloudup/apply_cluster.go

@@ -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

upup/pkg/fi/cloudup/awstasks/iamrole.go

@@ -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

upup/pkg/fi/cloudup/awstasks/securitygroup_test.go

@@ -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)
 		}

upup/pkg/fi/cloudup/awsup/BUILD.bazel

@@ -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",

upup/pkg/fi/cloudup/awsup/aws_cloud.go

@@ -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
 }
 

upup/pkg/fi/cloudup/awsup/mock_aws_cloud.go

@@ -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 {
+func (c *MockAWSCloud) IAM() iamiface.IAMAPI {
-	glog.Fatalf("MockAWSCloud IAM not implemented")
+	if c.MockIAM == nil {
-	return 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
 }

vendor/github.com/aws/aws-sdk-go/service/iam/iamiface/BUILD.bazel

@@ -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",
+    ],
+)

vendor/github.com/aws/aws-sdk-go/service/iam/iamiface/interface.go

@@ -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)

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/aws/aws.go

@@ -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