feat(PPS): Add support for private path service gateway and private path load balancer

ibm/acctest/acctest.go

@@ -23,6 +23,7 @@ const (
 )
 
 var (
+	AccountId                       string
 	AppIDTenantID                   string
 	AppIDTestUserEmail              string
 	BackupPolicyJobID               string
@@ -763,6 +764,17 @@ func init() {
 		fmt.Println("[INFO] Set the environment variable SL_CIDR_2 for testing ibm_is_subnet else it is set to default value '10.240.64.0/24'")
 	}
 
+	AccountId = os.Getenv("IS_ACCOUNT_ID")
+	if AccountId == "" {
+		AccountId = "fee82deba12e4c0fb69c3b09d1f12345"
+		fmt.Println("[INFO] Set the environment variable IS_ACCOUNT_ID for testing private_path_service_gateway_account_policy else it is set to default value 'fee82deba12e4c0fb69c3b09d1f12345'")
+	}
+
+	ISAddressPrefixCIDR = os.Getenv("SL_ADDRESS_PREFIX_CIDR")
+	if ISAddressPrefixCIDR == "" {
+		ISAddressPrefixCIDR = "10.120.0.0/24"
+		fmt.Println("[INFO] Set the environment variable SL_ADDRESS_PREFIX_CIDR for testing ibm_is_vpc_address_prefix else it is set to default value '10.120.0.0/24'")
+	}
 	ISCIDR2 = os.Getenv("SL_CIDR_2")
 	if ISCIDR2 == "" {
 		ISCIDR2 = "10.240.64.0/24"

ibm/service/vpc/data_source_ibm_is_lb.go

@@ -17,6 +17,7 @@ const (
 	name                      = "name"
 	poolAlgorithm             = "algorithm"
 	href                      = "href"
+	family                    = "family"
 	poolProtocol              = "protocol"
 	poolCreatedAt             = "created_at"
 	poolProvisioningStatus    = "provisioning_status"
@@ -50,6 +51,11 @@ func DataSourceIBMISLB() *schema.Resource {
 				Required:    true,
 				Description: "Load Balancer name",
 			},
+			isLBAccessMode: {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The access mode of this load balancer",
+			},
 			"dns": {
 				Type:        schema.TypeList,
 				Computed:    true,
@@ -74,7 +80,21 @@ func DataSourceIBMISLB() *schema.Resource {
 				Computed:    true,
 				Description: "Load Balancer type",
 			},
-
+			isLBAvailability: {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The availability of this load balancer",
+			},
+			isLBInstanceGroupsSupported: {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "Indicates whether this load balancer supports instance groups.",
+			},
+			isLBSourceIPPersistenceSupported: {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "Indicates whether this load balancer supports source IP session persistence.",
+			},
 			isLBUdpSupported: {
 				Type:        schema.TypeBool,
 				Computed:    true,
@@ -86,7 +106,11 @@ func DataSourceIBMISLB() *schema.Resource {
 				Computed:    true,
 				Description: "Load Balancer status",
 			},
-
+			isLbProfile: {
+				Type:        schema.TypeMap,
+				Computed:    true,
+				Description: "The profile to use for this load balancer",
+			},
 			isLBRouteMode: {
 				Type:        schema.TypeBool,
 				Computed:    true,
@@ -354,6 +378,18 @@ func lbGetByName(d *schema.ResourceData, meta interface{}, name string) error {
 	for _, lb := range allrecs {
 		if *lb.Name == name {
 			d.SetId(*lb.ID)
+			if lb.Availability != nil {
+				d.Set(isLBAvailability, *lb.Availability)
+			}
+			if lb.AccessMode != nil {
+				d.Set(isLBAccessMode, *lb.AccessMode)
+			}
+			if lb.InstanceGroupsSupported != nil {
+				d.Set(isLBInstanceGroupsSupported, *lb.InstanceGroupsSupported)
+			}
+			if lb.SourceIPSessionPersistenceSupported != nil {
+				d.Set(isLBSourceIPPersistenceSupported, *lb.SourceIPSessionPersistenceSupported)
+			}
 			dnsList := make([]map[string]interface{}, 0)
 			if lb.Dns != nil {
 				dns := map[string]interface{}{}
@@ -368,9 +404,18 @@ func lbGetByName(d *schema.ResourceData, meta interface{}, name string) error {
 			}
 			if *lb.IsPublic {
 				d.Set(isLBType, "public")
+			} else if lb.IsPrivatePath != nil && *lb.IsPrivatePath {
+				d.Set(isLBType, "private_path")
 			} else {
 				d.Set(isLBType, "private")
 			}
+			lbProfile := make(map[string]interface{})
+			if lb.Profile != nil {
+				lbProfile[isLBName] = *lb.Profile.Name
+				lbProfile[href] = *lb.Profile.Href
+				lbProfile[family] = *lb.Profile.Family
+			}
+			d.Set(isLbProfile, lbProfile)
 			d.Set(isLBStatus, *lb.ProvisioningStatus)
 			if lb.RouteMode != nil {
 				d.Set(isLBRouteMode, *lb.RouteMode)

ibm/service/vpc/data_source_ibm_is_lb_profile.go

@@ -24,6 +24,25 @@ func DataSourceIBMISLbProfile() *schema.Resource {
 				Required:    true,
 				Description: "The name for this load balancer profile",
 			},
+			isLBAccessModes: {
+				Type:        schema.TypeList,
+				Computed:    true,
+				Description: "The access mode for a load balancer with this profile",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The type for access mode",
+						},
+						"value": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "Access modes for this profile",
+						},
+					},
+				},
+			},
 			"href": {
 				Type:        schema.TypeString,
 				Computed:    true,
@@ -76,6 +95,19 @@ func dataSourceIBMISLbProfileRead(context context.Context, d *schema.ResourceDat
 	d.Set("name", *lbProfile.Name)
 	d.Set("href", *lbProfile.Href)
 	d.Set("family", *lbProfile.Family)
+	if lbProfile.AccessModes != nil {
+		accessModes := lbProfile.AccessModes
+		AccessModesMap := map[string]interface{}{}
+		AccessModesList := []map[string]interface{}{}
+		if accessModes.Type != nil {
+			AccessModesMap["type"] = *accessModes.Type
+		}
+		if len(accessModes.Values) > 0 {
+			AccessModesMap["value"] = accessModes.Values
+		}
+		AccessModesList = append(AccessModesList, AccessModesMap)
+		d.Set(isLBAccessModes, AccessModesList)
+	}
 	log.Printf("[INFO] lbprofile udp %v", lbProfile.UDPSupported)
 	if lbProfile.UDPSupported != nil {
 		udpSupport := lbProfile.UDPSupported

ibm/service/vpc/data_source_ibm_is_lb_profiles.go

@@ -34,6 +34,44 @@ func DataSourceIBMISLbProfiles() *schema.Resource {
 				Computed:    true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
+						isLBAccessModes: {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: "The access mode for a load balancer with this profile",
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"type": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "The type for access mode",
+									},
+									"value": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "Access modes for this profile",
+									},
+								},
+							},
+						},
+						"availability": {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: "The availability mode for a load balancer with this profile",
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"type": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "The type of availability, one of [fixed, dependent]",
+									},
+									"value": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "The availability of this load balancer, one of [subnet, region]. Applicable only if type is fixed",
+									},
+								},
+							},
+						},
 						"name": {
 							Type:        schema.TypeString,
 							Computed:    true,
@@ -49,6 +87,44 @@ func DataSourceIBMISLbProfiles() *schema.Resource {
 							Computed:    true,
 							Description: "The product family this load balancer profile belongs to",
 						},
+						"instance_groups_supported": {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: "The instance groups support for the load balancer with this profile",
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"type": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "The type of support for instance groups, one of [fixed, dependent]",
+									},
+									"value": {
+										Type:        schema.TypeBool,
+										Computed:    true,
+										Description: "Indicates whether Instance groups are supported for this profile. Applicable only if type is fixed",
+									},
+								},
+							},
+						},
+						"source_ip_session_persistence_supported": {
+							Type:        schema.TypeList,
+							Computed:    true,
+							Description: "The source IP session ip persistence support for a load balancer with this profile",
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"type": {
+										Type:        schema.TypeString,
+										Computed:    true,
+										Description: "The type of support for session ip persistence, one of [fixed, dependent on configuration]",
+									},
+									"value": {
+										Type:        schema.TypeBool,
+										Computed:    true,
+										Description: "Indicates whether session ip persistence are supported for this profile. Applicable only if type is fixed",
+									},
+								},
+							},
+						},
 						"route_mode_supported": {
 							Type:        schema.TypeBool,
 							Computed:    true,
@@ -175,6 +251,59 @@ func dataSourceIBMISLbProfilesRead(d *schema.ResourceData, meta interface{}) err
 				}
 			}
 		}
+
+		if profileCollector.AccessModes != nil {
+			accessModes := profileCollector.AccessModes
+			AccessModesMap := map[string]interface{}{}
+			AccessModesList := []map[string]interface{}{}
+			if accessModes.Type != nil {
+				AccessModesMap["type"] = *accessModes.Type
+			}
+			if len(accessModes.Values) > 0 {
+				AccessModesMap["value"] = accessModes.Values
+			}
+			AccessModesList = append(AccessModesList, AccessModesMap)
+			l[isLBAccessModes] = AccessModesList
+		}
+		if profileCollector.Availability != nil {
+			availabilitySupport := profileCollector.Availability.(*vpcv1.LoadBalancerProfileAvailability)
+			availabilitySupportMap := map[string]interface{}{}
+			availabilitySupportList := []map[string]interface{}{}
+			if availabilitySupport.Type != nil {
+				availabilitySupportMap["type"] = *availabilitySupport.Type
+			}
+			if availabilitySupport.Value != nil {
+				availabilitySupportMap["value"] = *availabilitySupport.Value
+			}
+			availabilitySupportList = append(availabilitySupportList, availabilitySupportMap)
+			l["availability"] = availabilitySupportList
+		}
+		if profileCollector.InstanceGroupsSupported != nil {
+			instanceGroupSupport := profileCollector.InstanceGroupsSupported.(*vpcv1.LoadBalancerProfileInstanceGroupsSupported)
+			instanceGroupSupportMap := map[string]interface{}{}
+			instanceGroupSupportList := []map[string]interface{}{}
+			if instanceGroupSupport.Type != nil {
+				instanceGroupSupportMap["type"] = *instanceGroupSupport.Type
+			}
+			if instanceGroupSupport.Value != nil {
+				instanceGroupSupportMap["value"] = *instanceGroupSupport.Value
+			}
+			instanceGroupSupportList = append(instanceGroupSupportList, instanceGroupSupportMap)
+			l["source_ip_session_persistence_supported"] = instanceGroupSupportList
+		}
+		if profileCollector.SourceIPSessionPersistenceSupported != nil {
+			sourceIpPersistenceSupport := profileCollector.SourceIPSessionPersistenceSupported.(*vpcv1.LoadBalancerProfileSourceIPSessionPersistenceSupported)
+			sourceIpPersistenceSupportMap := map[string]interface{}{}
+			sourceIpPersistenceSupportList := []map[string]interface{}{}
+			if sourceIpPersistenceSupport.Type != nil {
+				sourceIpPersistenceSupportMap["type"] = *sourceIpPersistenceSupport.Type
+			}
+			if sourceIpPersistenceSupport.Value != nil {
+				sourceIpPersistenceSupportMap["value"] = *sourceIpPersistenceSupport.Value
+			}
+			sourceIpPersistenceSupportList = append(sourceIpPersistenceSupportList, sourceIpPersistenceSupportMap)
+			l["instance_groups_supported"] = sourceIpPersistenceSupportList
+		}
 		lbprofilesInfo = append(lbprofilesInfo, l)
 	}
 	d.SetId(dataSourceIBMISLbProfilesID(d))

ibm/service/vpc/data_source_ibm_is_lb_test.go

@@ -29,6 +29,9 @@ func TestAccIBMISLBDatasource_basic(t *testing.T) {
 						"data.ibm_is_lb.ds_lb", "name", name),
 					resource.TestCheckResourceAttr(
 						"data.ibm_is_lb.ds_lb", "route_mode", routeMode),
+					resource.TestCheckResourceAttrSet("data.ibm_is_lb.ds_lb", "availability"),
+					resource.TestCheckResourceAttrSet("data.ibm_is_lb.ds_lb", "instance_groups_supported"),
+					resource.TestCheckResourceAttrSet("data.ibm_is_lb.ds_lb", "source_ip_persistence_supported"),
 				),
 			},
 		},

ibm/service/vpc/data_source_ibm_is_lbs.go

@@ -32,6 +32,11 @@ func DataSourceIBMISLBS() *schema.Resource {
 				Computed:    true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
+						isLBAccessMode: {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The access mode of this load balancer",
+						},
 						ID: {
 							Type:     schema.TypeString,
 							Computed: true,
@@ -75,6 +80,21 @@ func DataSourceIBMISLBS() *schema.Resource {
 							Computed:    true,
 							Description: "Load Balancer name",
 						},
+						isLBAvailability: {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The availability of this load balancer",
+						},
+						isLBInstanceGroupsSupported: {
+							Type:        schema.TypeBool,
+							Computed:    true,
+							Description: "Indicates whether this load balancer supports instance groups.",
+						},
+						isLBSourceIPPersistenceSupported: {
+							Type:        schema.TypeBool,
+							Computed:    true,
+							Description: "Indicates whether this load balancer supports source IP session persistence.",
+						},
 						isLBUdpSupported: {
 							Type:        schema.TypeBool,
 							Computed:    true,
@@ -321,6 +341,18 @@ func getLbs(d *schema.ResourceData, meta interface{}) error {
 		lbInfo := make(map[string]interface{})
 		//	log.Printf("******* lb ******** : (%+v)", lb)
 		lbInfo[ID] = *lb.ID
+		if lb.Availability != nil {
+			lbInfo[isLBAvailability] = *lb.Availability
+		}
+		if lb.AccessMode != nil {
+			lbInfo[isLBAccessMode] = *lb.AccessMode
+		}
+		if lb.InstanceGroupsSupported != nil {
+			lbInfo[isLBInstanceGroupsSupported] = *lb.InstanceGroupsSupported
+		}
+		if lb.SourceIPSessionPersistenceSupported != nil {
+			lbInfo[isLBSourceIPPersistenceSupported] = *lb.SourceIPSessionPersistenceSupported
+		}
 		lbInfo[isLBName] = *lb.Name
 		dnsList := make([]map[string]interface{}, 0)
 		if lb.Dns != nil {
@@ -342,6 +374,8 @@ func getLbs(d *schema.ResourceData, meta interface{}) error {
 		lbInfo[CreatedAt] = lb.CreatedAt.String()
 		if *lb.IsPublic {
 			lbInfo[isLBType] = "public"
+		} else if *lb.IsPrivatePath {
+			lbInfo[isLBType] = "private_path"
 		} else {
 			lbInfo[isLBType] = "private"
 		}
@@ -437,7 +471,7 @@ func getLbs(d *schema.ResourceData, meta interface{}) error {
 			lbProfile := make(map[string]interface{})
 			lbProfile[name] = *lb.Profile.Name
 			lbProfile[href] = *lb.Profile.Href
-			lbProfile["family"] = *lb.Profile.Family
+			lbProfile[family] = *lb.Profile.Family
 			lbInfo[isLbProfile] = lbProfile
 		}
 		lbInfo[isLBResourceGroup] = *lb.ResourceGroup.ID