Support for HTTP2 and Advance Rules Sets added to load balancer

Author: Abdurahman Sherif

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Added
 - Support for updating instance type in `oci_oce_oce_instance`
 - Support for private native vcn clusters to `container_engine`
+- Support for HTTP2 and Advance Rules Sets added to `load_balancer`
 
 ## 4.17.0 (March 10, 2021)
 

oci/export_definitions.go

@@ -1524,6 +1524,13 @@ var exportLoadBalancerPathRouteSetHints = &TerraformResourceHints{
 	resourceAbbreviation: "path_route_set",
 }
 
+var exportLoadBalancerLoadBalancerRoutingPolicyHints = &TerraformResourceHints{
+	resourceClass:        "oci_load_balancer_load_balancer_routing_policy",
+	datasourceClass:      "oci_load_balancer_load_balancer_routing_policies",
+	datasourceItemsAttr:  "routing_policies",
+	resourceAbbreviation: "load_balancer_routing_policy",
+}
+
 var exportLoadBalancerRuleSetHints = &TerraformResourceHints{
 	resourceClass:        "oci_load_balancer_rule_set",
 	datasourceClass:      "oci_load_balancer_rule_sets",

oci/export_graphs.go

@@ -656,6 +656,12 @@ var loadBalancerResourceGraph = TerraformResourceGraph{
 				"load_balancer_id": "id",
 			},
 		},
+		{
+			TerraformResourceHints: exportLoadBalancerLoadBalancerRoutingPolicyHints,
+			datasourceQueryParams: map[string]string{
+				"load_balancer_id": "id",
+			},
+		},
 		{
 			TerraformResourceHints: exportLoadBalancerPathRouteSetHints,
 			datasourceQueryParams: map[string]string{

oci/export_helpers.go

@@ -28,6 +28,14 @@ func init() {
 	exportIdentitySwiftPasswordHints.getIdFn = getIdentitySwiftPasswordId
 	exportKmsKeyHints.getIdFn = getKmsKeyId
 	exportKmsKeyVersionHints.getIdFn = getKmsKeyVersionId
+	exportLoadBalancerBackendHints.getIdFn = getLoadBalancerBackendId
+	exportLoadBalancerBackendSetHints.getIdFn = getLoadBalancerBackendSetId
+	exportLoadBalancerCertificateHints.getIdFn = getLoadBalancerCertificateId
+	exportLoadBalancerHostnameHints.getIdFn = getLoadBalancerHostnameId
+	exportLoadBalancerListenerHints.getIdFn = getLoadBalancerListenerId
+	exportLoadBalancerPathRouteSetHints.getIdFn = getLoadBalancerPathRouteSetId
+	exportLoadBalancerLoadBalancerRoutingPolicyHints.getIdFn = getLoadBalancerLoadBalancerRoutingPolicyId
+	exportLoadBalancerRuleSetHints.getIdFn = getLoadBalancerRuleSetId
 	exportNosqlIndexHints.getIdFn = getNosqlIndexId
 	exportObjectStorageBucketHints.getIdFn = getObjectStorageBucketId
 	exportObjectStorageObjectLifecyclePolicyHints.getIdFn = getObjectStorageObjectLifecyclePolicyId
@@ -317,6 +325,16 @@ func getLoadBalancerPathRouteSetId(resource *OCIResource) (string, error) {
 	return getPathRouteSetCompositeId(loadBalancerId, pathRouteSetName), nil
 }
 
+func getLoadBalancerLoadBalancerRoutingPolicyId(resource *OCIResource) (string, error) {
+
+	loadBalancerId := resource.parent.id
+	routingPolicyName, ok := resource.sourceAttributes["name"].(string)
+	if !ok {
+		return "", fmt.Errorf("[ERROR] unable to find routingPolicyName for LoadBalancer LoadBalancerRoutingPolicy")
+	}
+	return getLoadBalancerRoutingPolicyCompositeId(loadBalancerId, routingPolicyName), nil
+}
+
 func getLoadBalancerRuleSetId(resource *OCIResource) (string, error) {
 
 	loadBalancerId := resource.parent.id

oci/export_resource_helpers.go

@@ -660,6 +660,7 @@ func init() {
 	exportLoadBalancerListenerHints.processDiscoveredResourcesFn = processLoadBalancerListeners
 	exportLoadBalancerPathRouteSetHints.processDiscoveredResourcesFn = processLoadBalancerPathRouteSets
 	exportLoadBalancerRuleSetHints.processDiscoveredResourcesFn = processLoadBalancerRuleSets
+	exportLoadBalancerLoadBalancerRoutingPolicyHints.processDiscoveredResourcesFn = processLoadBalancerRoutingPolicies
 
 	exportCoreBootVolumeHints.processDiscoveredResourcesFn = filterSourcedBootVolumes
 	exportCoreCrossConnectGroupHints.discoverableLifecycleStates = append(exportCoreCrossConnectGroupHints.discoverableLifecycleStates, string(oci_core.CrossConnectGroupLifecycleStateInactive))
@@ -1211,6 +1212,19 @@ func processLoadBalancerPathRouteSets(ctx *resourceDiscoveryContext, resources [
 	return resources, nil
 }
 
+func processLoadBalancerRoutingPolicies(ctx *resourceDiscoveryContext, resources []*OCIResource) ([]*OCIResource, error) {
+	for _, routingPolicy := range resources {
+		if routingPolicy.parent == nil {
+			continue
+		}
+
+		routingPolicy.id = getLoadBalancerRoutingPolicyCompositeId(routingPolicy.parent.id, routingPolicy.sourceAttributes["name"].(string))
+		routingPolicy.sourceAttributes["load_balancer_id"] = routingPolicy.parent.id
+	}
+
+	return resources, nil
+}
+
 func processLoadBalancerRuleSets(ctx *resourceDiscoveryContext, resources []*OCIResource) ([]*OCIResource, error) {
 	for _, ruleSet := range resources {
 		if ruleSet.parent == nil {

oci/load_balancer_listener_resource.go

@@ -96,6 +96,11 @@ func LoadBalancerListenerResource() *schema.Resource {
 				Optional: true,
 				Computed: true,
 			},
+			"routing_policy_name": {
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+			},
 			"rule_set_names": {
 				Type:     schema.TypeList,
 				Optional: true,
@@ -298,6 +303,11 @@ func (s *LoadBalancerListenerResourceCrud) Create() error {
 		request.Protocol = &tmp
 	}
 
+	if routingPolicyName, ok := s.D.GetOkExists("routing_policy_name"); ok {
+		tmp := routingPolicyName.(string)
+		request.RoutingPolicyName = &tmp
+	}
+
 	if ruleSetNames, ok := s.D.GetOkExists("rule_set_names"); ok {
 		interfaces := ruleSetNames.([]interface{})
 		tmp := make([]string, len(interfaces))
@@ -449,6 +459,11 @@ func (s *LoadBalancerListenerResourceCrud) Update() error {
 		request.Protocol = &tmp
 	}
 
+	if routingPolicyName, ok := s.D.GetOkExists("routing_policy_name"); ok {
+		tmp := routingPolicyName.(string)
+		request.RoutingPolicyName = &tmp
+	}
+
 	if ruleSetNames, ok := s.D.GetOkExists("rule_set_names"); ok {
 		interfaces := ruleSetNames.([]interface{})
 		tmp := make([]string, len(interfaces))

oci/load_balancer_listener_test.go

@@ -31,6 +31,7 @@ var (
 		"connection_configuration": RepresentationGroup{Optional, listenerConnectionConfigurationRepresentation},
 		"hostname_names":           Representation{repType: Optional, create: []string{`${oci_load_balancer_hostname.test_hostname.name}`}},
 		"path_route_set_name":      Representation{repType: Optional, create: `${oci_load_balancer_path_route_set.test_path_route_set.name}`},
+		"routing_policy_name":      Representation{repType: Optional, create: `${oci_load_balancer_load_balancer_routing_policy.test_load_balancer_routing_policy.name}`},
 		"rule_set_names":           Representation{repType: Optional, create: []string{`${oci_load_balancer_rule_set.test_rule_set.name}`}},
 		"ssl_configuration":        RepresentationGroup{Optional, listenerSslConfigurationRepresentation},
 	}
@@ -43,7 +44,8 @@ var (
 		"verify_peer_certificate": Representation{repType: Optional, create: `false`, update: `true`},
 	}
 
-	ListenerResourceDependencies = generateResourceFromRepresentationMap("oci_load_balancer_backend_set", "test_backend_set", Required, Create, backendSetRepresentation) +
+	ListenerResourceDependencies = generateResourceFromRepresentationMap("oci_load_balancer_load_balancer_routing_policy", "test_load_balancer_routing_policy", Required, Create, loadBalancerRoutingPolicyRepresentation) +
+		generateResourceFromRepresentationMap("oci_load_balancer_backend_set", "test_backend_set", Required, Create, backendSetRepresentation) +
 		generateResourceFromRepresentationMap("oci_load_balancer_certificate", "test_certificate", Optional, Create, certificateRepresentation) +
 		generateResourceFromRepresentationMap("oci_load_balancer_load_balancer", "test_load_balancer", Required, Create, loadBalancerRepresentation) +
 		LoadBalancerSubnetDependencies +
@@ -123,6 +125,7 @@ func TestLoadBalancerListenerResource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(resourceName, "path_route_set_name"),
 					resource.TestCheckResourceAttr(resourceName, "port", "10"),
 					resource.TestCheckResourceAttr(resourceName, "protocol", "HTTP"),
+					resource.TestCheckResourceAttrSet(resourceName, "routing_policy_name"),
 					resource.TestCheckResourceAttr(resourceName, "rule_set_names.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "ssl_configuration.#", "1"),
 					resource.TestCheckResourceAttrSet(resourceName, "ssl_configuration.0.certificate_name"),
@@ -156,6 +159,7 @@ func TestLoadBalancerListenerResource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(resourceName, "path_route_set_name"),
 					resource.TestCheckResourceAttr(resourceName, "port", "11"),
 					resource.TestCheckResourceAttr(resourceName, "protocol", "HTTP"),
+					resource.TestCheckResourceAttrSet(resourceName, "routing_policy_name"),
 					resource.TestCheckResourceAttr(resourceName, "rule_set_names.#", "1"),
 					resource.TestCheckResourceAttr(resourceName, "ssl_configuration.#", "1"),
 					resource.TestCheckResourceAttrSet(resourceName, "ssl_configuration.0.certificate_name"),

oci/load_balancer_load_balancer_routing_policies_data_source.go

@@ -0,0 +1,119 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package oci
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	oci_load_balancer "github.com/oracle/oci-go-sdk/v36/loadbalancer"
+)
+
+func init() {
+	RegisterDatasource("oci_load_balancer_load_balancer_routing_policies", LoadBalancerLoadBalancerRoutingPoliciesDataSource())
+}
+
+func LoadBalancerLoadBalancerRoutingPoliciesDataSource() *schema.Resource {
+	return &schema.Resource{
+		Read: readLoadBalancerLoadBalancerRoutingPolicies,
+		Schema: map[string]*schema.Schema{
+			"filter": dataSourceFiltersSchema(),
+			"load_balancer_id": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"routing_policies": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem:     LoadBalancerLoadBalancerRoutingPolicyResource(),
+			},
+		},
+	}
+}
+
+func readLoadBalancerLoadBalancerRoutingPolicies(d *schema.ResourceData, m interface{}) error {
+	sync := &LoadBalancerLoadBalancerRoutingPoliciesDataSourceCrud{}
+	sync.D = d
+	sync.Client = m.(*OracleClients).loadBalancerClient()
+
+	return ReadResource(sync)
+}
+
+type LoadBalancerLoadBalancerRoutingPoliciesDataSourceCrud struct {
+	D      *schema.ResourceData
+	Client *oci_load_balancer.LoadBalancerClient
+	Res    *oci_load_balancer.ListRoutingPoliciesResponse
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPoliciesDataSourceCrud) VoidState() {
+	s.D.SetId("")
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPoliciesDataSourceCrud) Get() error {
+	request := oci_load_balancer.ListRoutingPoliciesRequest{}
+
+	if loadBalancerId, ok := s.D.GetOkExists("load_balancer_id"); ok {
+		tmp := loadBalancerId.(string)
+		request.LoadBalancerId = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = getRetryPolicy(false, "load_balancer")
+
+	response, err := s.Client.ListRoutingPolicies(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	s.Res = &response
+	request.Page = s.Res.OpcNextPage
+
+	for request.Page != nil {
+		listResponse, err := s.Client.ListRoutingPolicies(context.Background(), request)
+		if err != nil {
+			return err
+		}
+
+		s.Res.Items = append(s.Res.Items, listResponse.Items...)
+		request.Page = listResponse.OpcNextPage
+	}
+
+	return nil
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPoliciesDataSourceCrud) SetData() error {
+	if s.Res == nil {
+		return nil
+	}
+
+	s.D.SetId(GenerateDataSourceHashID("LoadBalancerLoadBalancerRoutingPoliciesDataSource-", LoadBalancerLoadBalancerRoutingPoliciesDataSource(), s.D))
+	resources := []map[string]interface{}{}
+
+	for _, r := range s.Res.Items {
+		loadBalancerRoutingPolicy := map[string]interface{}{}
+
+		loadBalancerRoutingPolicy["condition_language_version"] = r.ConditionLanguageVersion
+
+		if r.Name != nil {
+			loadBalancerRoutingPolicy["name"] = *r.Name
+		}
+
+		rules := []interface{}{}
+		for _, item := range r.Rules {
+			rules = append(rules, RoutingRuleToMap(item))
+		}
+		loadBalancerRoutingPolicy["rules"] = rules
+
+		resources = append(resources, loadBalancerRoutingPolicy)
+	}
+
+	if f, fOk := s.D.GetOkExists("filter"); fOk {
+		resources = ApplyFilters(f.(*schema.Set), resources, LoadBalancerLoadBalancerRoutingPoliciesDataSource().Schema["routing_policies"].Elem.(*schema.Resource).Schema)
+	}
+
+	if err := s.D.Set("routing_policies", resources); err != nil {
+		return err
+	}
+
+	return nil
+}

oci/load_balancer_load_balancer_routing_policy_data_source.go

@@ -0,0 +1,92 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package oci
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	oci_load_balancer "github.com/oracle/oci-go-sdk/v36/loadbalancer"
+)
+
+func init() {
+	RegisterDatasource("oci_load_balancer_load_balancer_routing_policy", LoadBalancerLoadBalancerRoutingPolicyDataSource())
+}
+
+func LoadBalancerLoadBalancerRoutingPolicyDataSource() *schema.Resource {
+	fieldMap := make(map[string]*schema.Schema)
+	fieldMap["load_balancer_id"] = &schema.Schema{
+		Type:     schema.TypeString,
+		Required: true,
+	}
+	fieldMap["routing_policy_name"] = &schema.Schema{
+		Type:     schema.TypeString,
+		Required: true,
+	}
+	return GetSingularDataSourceItemSchema(LoadBalancerLoadBalancerRoutingPolicyResource(), fieldMap, readSingularLoadBalancerLoadBalancerRoutingPolicy)
+}
+
+func readSingularLoadBalancerLoadBalancerRoutingPolicy(d *schema.ResourceData, m interface{}) error {
+	sync := &LoadBalancerLoadBalancerRoutingPolicyDataSourceCrud{}
+	sync.D = d
+	sync.Client = m.(*OracleClients).loadBalancerClient()
+
+	return ReadResource(sync)
+}
+
+type LoadBalancerLoadBalancerRoutingPolicyDataSourceCrud struct {
+	D      *schema.ResourceData
+	Client *oci_load_balancer.LoadBalancerClient
+	Res    *oci_load_balancer.GetRoutingPolicyResponse
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPolicyDataSourceCrud) VoidState() {
+	s.D.SetId("")
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPolicyDataSourceCrud) Get() error {
+	request := oci_load_balancer.GetRoutingPolicyRequest{}
+
+	if loadBalancerId, ok := s.D.GetOkExists("load_balancer_id"); ok {
+		tmp := loadBalancerId.(string)
+		request.LoadBalancerId = &tmp
+	}
+
+	if routingPolicyName, ok := s.D.GetOkExists("routing_policy_name"); ok {
+		tmp := routingPolicyName.(string)
+		request.RoutingPolicyName = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = getRetryPolicy(false, "load_balancer")
+
+	response, err := s.Client.GetRoutingPolicy(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	s.Res = &response
+	return nil
+}
+
+func (s *LoadBalancerLoadBalancerRoutingPolicyDataSourceCrud) SetData() error {
+	if s.Res == nil {
+		return nil
+	}
+
+	s.D.SetId(GenerateDataSourceHashID("LoadBalancerLoadBalancerRoutingPolicyDataSource-", LoadBalancerLoadBalancerRoutingPolicyDataSource(), s.D))
+
+	s.D.Set("condition_language_version", s.Res.ConditionLanguageVersion)
+
+	if s.Res.Name != nil {
+		s.D.Set("name", *s.Res.Name)
+	}
+
+	rules := []interface{}{}
+	for _, item := range s.Res.Rules {
+		rules = append(rules, RoutingRuleToMap(item))
+	}
+	s.D.Set("rules", rules)
+
+	return nil
+}