include tests

cloudmock/aws/mockelbv2/BUILD.bazel

@@ -0,0 +1,14 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["api.go"],
+    importpath = "k8s.io/kops/cloudmock/aws/mockelbv2",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/aws/aws-sdk-go/aws:go_default_library",
+        "//vendor/github.com/aws/aws-sdk-go/service/elbv2:go_default_library",
+        "//vendor/github.com/aws/aws-sdk-go/service/elbv2/elbv2iface:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+    ],
+)

cloudmock/aws/mockelbv2/api.go

@@ -0,0 +1,213 @@
+/*
+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 mockelbv2
+
+import (
+	"sync"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/elbv2"
+	"github.com/aws/aws-sdk-go/service/elbv2/elbv2iface"
+	"github.com/golang/glog"
+)
+
+const elbZoneID = "FAKEZONE-CLOUDMOCK-ELBV2"
+
+type MockELBV2 struct {
+	elbv2iface.ELBV2API
+
+	mutex sync.Mutex
+
+	LoadBalancers map[string]*loadBalancer
+	TargetGroups  map[string]*targetGroup
+}
+
+type loadBalancer struct {
+	description elbv2.LoadBalancer
+	//attributes  elbv2.LoadBalancerAttribute
+	tags map[string]string
+}
+
+type targetGroup struct {
+	description elbv2.TargetGroup
+	//attributes  elbv2.LoadBalancerAttribute
+	tags map[string]string
+}
+
+func (m *MockELBV2) DescribeLoadBalancers(request *elbv2.DescribeLoadBalancersInput) (*elbv2.DescribeLoadBalancersOutput, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	glog.V(2).Infof("DescribeLoadBalancers v2 %v", request)
+
+	if request.PageSize != nil {
+		glog.Warningf("PageSize not implemented")
+	}
+	if request.Marker != nil {
+		glog.Fatalf("Marker not implemented")
+	}
+
+	var elbs []*elbv2.LoadBalancer
+	for _, elb := range m.LoadBalancers {
+		match := false
+
+		if len(request.LoadBalancerArns) > 0 {
+			for _, name := range request.LoadBalancerArns {
+				if aws.StringValue(elb.description.LoadBalancerArn) == aws.StringValue(name) {
+					match = true
+				}
+			}
+		} else {
+			match = true
+		}
+
+		if match {
+			elbs = append(elbs, &elb.description)
+		}
+	}
+
+	return &elbv2.DescribeLoadBalancersOutput{
+		LoadBalancers: elbs,
+	}, nil
+}
+
+func (m *MockELBV2) DescribeLoadBalancersPages(request *elbv2.DescribeLoadBalancersInput, callback func(p *elbv2.DescribeLoadBalancersOutput, lastPage bool) (shouldContinue bool)) error {
+	// For the mock, we just send everything in one page
+	page, err := m.DescribeLoadBalancers(request)
+	if err != nil {
+		return err
+	}
+
+	callback(page, false)
+
+	return nil
+}
+
+func (m *MockELBV2) DescribeTargetGroups(request *elbv2.DescribeTargetGroupsInput) (*elbv2.DescribeTargetGroupsOutput, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	glog.V(2).Infof("DescribeTargetGroups %v", request)
+
+	if request.PageSize != nil {
+		glog.Warningf("PageSize not implemented")
+	}
+	if request.Marker != nil {
+		glog.Fatalf("Marker not implemented")
+	}
+
+	var tgs []*elbv2.TargetGroup
+	for _, tg := range m.TargetGroups {
+		match := false
+
+		if len(request.TargetGroupArns) > 0 {
+			for _, name := range request.TargetGroupArns {
+				if aws.StringValue(tg.description.TargetGroupArn) == aws.StringValue(name) {
+					match = true
+				}
+			}
+		} else {
+			match = true
+		}
+
+		if match {
+			tgs = append(tgs, &tg.description)
+		}
+	}
+
+	return &elbv2.DescribeTargetGroupsOutput{
+		TargetGroups: tgs,
+	}, nil
+}
+
+func (m *MockELBV2) DescribeTargetGroupsPages(request *elbv2.DescribeTargetGroupsInput, callback func(p *elbv2.DescribeTargetGroupsOutput, lastPage bool) (shouldContinue bool)) error {
+	page, err := m.DescribeTargetGroups(request)
+	if err != nil {
+		return err
+	}
+
+	callback(page, false)
+
+	return nil
+}
+
+/*
+func (m *MockELBV2) CreateLoadBalancer(request *elbv2.CreateLoadBalancerInput) (*elbv2.CreateLoadBalancerOutput, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	glog.V(2).Infof("CreateLoadBalancer v2 %v", request)
+	createdTime := time.Now().UTC()
+
+	dnsName := *request.Name + ".elbv2.cloudmock.com"
+
+	lb := &loadBalancer{
+		description: elbv2.LoadBalancer{
+			//AvailabilityZones: request.AvailabilityZones,
+			CreatedTime:      &createdTime,
+			LoadBalancerName: request.Name,
+			Scheme:           request.Scheme,
+			//Subnets:          request.Subnets,
+			DNSName: aws.String(dnsName),
+			Type:    request.Type,
+
+			CanonicalHostedZoneId: aws.String(elbZoneID),
+		},
+		tags: make(map[string]string),
+	}
+
+	//for _, listener := range request.Listeners {
+	//	lb.description.ListenerDescriptions = append(lb.description.ListenerDescriptions, &elbv2.ListenerDescription{
+	//		Listener: listener,
+	//	})
+	//}
+
+	// for _, tag := range input.Tags {
+	// 	g.Tags = append(g.Tags, &autoscaling.TagDescription{
+	// 		Key:               tag.Key,
+	// 		PropagateAtLaunch: tag.PropagateAtLaunch,
+	// 		ResourceId:        tag.ResourceId,
+	// 		ResourceType:      tag.ResourceType,
+	// 		Value:             tag.Value,
+	// 	})
+	// }
+
+	if m.LoadBalancers == nil {
+		m.LoadBalancers = make(map[string]*loadBalancer)
+	}
+	m.LoadBalancers[*request.Name] = lb
+
+	return &elbv2.CreateLoadBalancerOutput{}, nil
+}
+
+func (m *MockELBV2) DeleteLoadBalancer(request *elbv2.DeleteLoadBalancerInput) (*elbv2.DeleteLoadBalancerOutput, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	glog.Infof("DeleteLoadBalancer: %v", request)
+
+	id := aws.StringValue(request.LoadBalancerArn)
+	o := m.LoadBalancers[id]
+	if o == nil {
+		return nil, fmt.Errorf("LoadBalancer %q not found", id)
+	}
+	delete(m.LoadBalancers, id)
+
+	return &elbv2.DeleteLoadBalancerOutput{}, nil
+}
+
+*/

pkg/testutils/integrationtestharness.go

@@ -31,6 +31,7 @@ import (
 	"k8s.io/kops/cloudmock/aws/mockautoscaling"
 	"k8s.io/kops/cloudmock/aws/mockec2"
 	"k8s.io/kops/cloudmock/aws/mockelb"
+	"k8s.io/kops/cloudmock/aws/mockelbv2"
 	"k8s.io/kops/cloudmock/aws/mockiam"
 	"k8s.io/kops/cloudmock/aws/mockroute53"
 	"k8s.io/kops/pkg/apis/kops"
@@ -105,6 +106,8 @@ func (h *IntegrationTestHarness) SetupMockAWS() *awsup.MockAWSCloud {
 	cloud.MockRoute53 = mockRoute53
 	mockELB := &mockelb.MockELB{}
 	cloud.MockELB = mockELB
+	mockELBV2 := &mockelbv2.MockELBV2{}
+	cloud.MockELBV2 = mockELBV2
 	mockIAM := &mockiam.MockIAM{}
 	cloud.MockIAM = mockIAM
 	mockAutoscaling := &mockautoscaling.MockAutoscaling{}

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

@@ -818,6 +818,68 @@ func createELBTags(c AWSCloud, loadBalancerName string, tags map[string]string)
 	}
 }
 
+func (c *awsCloudImplementation) GetELBV2Tags(ResourceArn string) (map[string]string, error) {
+	return getELBV2Tags(c, ResourceArn)
+}
+
+func getELBV2Tags(c AWSCloud, ResourceArn string) (map[string]string, error) {
+	tags := map[string]string{}
+
+	request := &elbv2.DescribeTagsInput{
+		ResourceArns: []*string{&ResourceArn},
+	}
+
+	attempt := 0
+	for {
+		attempt++
+
+		response, err := c.ELBV2().DescribeTags(request)
+		if err != nil {
+			return nil, fmt.Errorf("error listing tags on %v: %v", ResourceArn, err)
+		}
+
+		for _, tagset := range response.TagDescriptions {
+			for _, tag := range tagset.Tags {
+				tags[aws.StringValue(tag.Key)] = aws.StringValue(tag.Value)
+			}
+		}
+
+		return tags, nil
+	}
+}
+
+func (c *awsCloudImplementation) CreateELBV2Tags(ResourceArn string, tags map[string]string) error {
+	return createELBV2Tags(c, ResourceArn, tags)
+}
+
+func createELBV2Tags(c AWSCloud, ResourceArn string, tags map[string]string) error {
+	if len(tags) == 0 {
+		return nil
+	}
+
+	elbv2Tags := []*elbv2.Tag{}
+	for k, v := range tags {
+		elbv2Tags = append(elbv2Tags, &elbv2.Tag{Key: aws.String(k), Value: aws.String(v)})
+	}
+
+	attempt := 0
+	for {
+		attempt++
+
+		request := &elbv2.AddTagsInput{
+			Tags:         elbv2Tags,
+			ResourceArns: []*string{&ResourceArn},
+		}
+
+		_, err := c.ELBV2().AddTags(request)
+		if err != nil {
+			return fmt.Errorf("error creating tags on %v: %v", ResourceArn, err)
+		}
+
+		return nil
+	}
+}
+
 func (c *awsCloudImplementation) BuildTags(name *string) map[string]string {
 	return buildTags(c.tags, name)
 }

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

@@ -160,6 +160,14 @@ func (c *MockAWSCloud) CreateELBTags(loadBalancerName string, tags map[string]st
 	return createELBTags(c, loadBalancerName, tags)
 }
 
+func (c *MockAWSCloud) GetELBV2Tags(ResourceArn string) (map[string]string, error) {
+	return getELBV2Tags(c, ResourceArn)
+}
+
+func (c *MockAWSCloud) CreateELBV2Tags(ResourceArn string, tags map[string]string) error {
+	return createELBV2Tags(c, ResourceArn, tags)
+}
+
 func (c *MockAWSCloud) DescribeInstance(instanceID string) (*ec2.Instance, error) {
 	return nil, fmt.Errorf("MockAWSCloud DescribeInstance not implemented")
 }