fixed the validation for protocols in sg and network acl

go.mod

@@ -41,7 +41,7 @@ require (
 	github.com/IBM/secrets-manager-go-sdk/v2 v2.0.15
 	github.com/IBM/vmware-go-sdk v0.1.5
 	github.com/IBM/vpc-beta-go-sdk v0.8.0
-	github.com/IBM/vpc-go-sdk v0.78.0
+	github.com/IBM/vpc-go-sdk v0.78.1
 	github.com/ScaleFT/sshkeys v0.0.0-20200327173127-6142f742bca5
 	github.com/akamai/AkamaiOPEN-edgegrid-golang v1.2.2
 	github.com/akamai/AkamaiOPEN-edgegrid-golang/v5 v5.0.0

go.sum

@@ -170,8 +170,8 @@ github.com/IBM/vmware-go-sdk v0.1.5 h1:aQbwcJBceaaauuIoJ0OJn+ttwjb+QTX6XV9Jbrdpj
 github.com/IBM/vmware-go-sdk v0.1.5/go.mod h1:OyQKRInGGsBaOyE5LIZCqH7b1DZ01BvIYa8BgGy+wWo=
 github.com/IBM/vpc-beta-go-sdk v0.8.0 h1:cEPpv4iw3Ba5W2d0AWg3TIbKeJ8y1nPuUuibR5Jt9eE=
 github.com/IBM/vpc-beta-go-sdk v0.8.0/go.mod h1:hORgIyTFRzXrZIK9IohaWmCRBBlYiDRagsufi7M6akE=
-github.com/IBM/vpc-go-sdk v0.78.0 h1:hOQfNt6cOG+r8ZItrJ2vDvkwC7HJsiU/+JxFKh+Xqb8=
-github.com/IBM/vpc-go-sdk v0.78.0/go.mod h1:85bJ/0FS7vYAifHdZvlnXypf8pQSmuf9kxReDDI5ZdY=
+github.com/IBM/vpc-go-sdk v0.78.1 h1:vzc1GIoTYZsQCoDWpvS5Ah13qfBfN7wWgTGnHhpBg0M=
+github.com/IBM/vpc-go-sdk v0.78.1/go.mod h1:85bJ/0FS7vYAifHdZvlnXypf8pQSmuf9kxReDDI5ZdY=
 github.com/Logicalis/asn1 v0.0.0-20190312173541-d60463189a56 h1:vuquMR410psHNax14XKNWa0Ae/kYgWJcXi0IFuX60N0=
 github.com/Logicalis/asn1 v0.0.0-20190312173541-d60463189a56/go.mod h1:Zb3OT4l0mf7P/GOs2w2Ilj5sdm5Whoq3pa24dAEBHFc=
 github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=

ibm/service/vpc/data_source_ibm_is_network_acl.go

@@ -650,6 +650,29 @@ func dataSourceNetworkACLRulesToMap(rule vpcv1.NetworkACLRuleItemIntf) (rulesMap
 			rulesMap[isNetworkACLRuleTCP] = make([]map[string]int, 0, 0)
 			rulesMap[isNetworkACLRuleUDP] = make([]map[string]int, 0, 0)
 		}
+	case "*vpcv1.NetworkACLRuleItem":
+		{
+			rulex := rule.(*vpcv1.NetworkACLRuleItem)
+			rulesMap["id"] = *rulex.ID
+			rulesMap[isNetworkACLRuleHref] = *rulex.Href
+			rulesMap[isNetworkACLRuleProtocol] = *rulex.Protocol
+			if rulex.Before != nil {
+				beforeList := []map[string]interface{}{}
+				beforeMap := dataSourceNetworkACLRulesBeforeToMap(*rulex.Before)
+				beforeList = append(beforeList, beforeMap)
+				rulesMap["before"] = beforeList
+			}
+			rulesMap["created_at"] = flex.DateTimeToString(rulex.CreatedAt)
+			rulesMap[isNetworkACLRuleName] = *rulex.Name
+			rulesMap[isNetworkACLRuleAction] = *rulex.Action
+			rulesMap[isNetworkACLRuleIPVersion] = *rulex.IPVersion
+			rulesMap[isNetworkACLRuleSource] = *rulex.Source
+			rulesMap[isNetworkACLRuleDestination] = *rulex.Destination
+			rulesMap[isNetworkACLRuleDirection] = *rulex.Direction
+			rulesMap[isNetworkACLRuleICMP] = make([]map[string]int, 0, 0)
+			rulesMap[isNetworkACLRuleTCP] = make([]map[string]int, 0, 0)
+			rulesMap[isNetworkACLRuleUDP] = make([]map[string]int, 0, 0)
+		}
 	}
 
 	return rulesMap

ibm/service/vpc/data_source_ibm_is_network_acl_rule.go

@@ -446,6 +446,47 @@ func nawaclRuleDataGet(context context.Context, d *schema.ResourceData, meta int
 					break
 				}
 			}
+		case "*vpcv1.NetworkACLRuleItem":
+			{
+				networkACLRule := rule.(*vpcv1.NetworkACLRuleItem)
+				if *networkACLRule.Name == name {
+					d.SetId(makeTerraformACLRuleID(nwACLID, *networkACLRule.ID))
+					d.Set(isNwACLRuleId, *networkACLRule.ID)
+					if networkACLRule.Before != nil {
+						if err = d.Set("before", *networkACLRule.Before.ID); err != nil {
+							return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting before: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-before").GetDiag()
+						}
+					}
+					if err = d.Set("href", networkACLRule.Href); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting href: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-href").GetDiag()
+					}
+					if err = d.Set("protocol", networkACLRule.Protocol); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting protocol: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-protocol").GetDiag()
+					}
+					if err = d.Set("name", networkACLRule.Name); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting name: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-name").GetDiag()
+					}
+					if err = d.Set("action", networkACLRule.Action); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting action: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-action").GetDiag()
+					}
+					if err = d.Set("ip_version", networkACLRule.IPVersion); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting ip_version: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-ip_version").GetDiag()
+					}
+					if err = d.Set("source", networkACLRule.Source); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting source: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-source").GetDiag()
+					}
+					if err = d.Set("destination", networkACLRule.Destination); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting destination: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-destination").GetDiag()
+					}
+					if err = d.Set("direction", networkACLRule.Direction); err != nil {
+						return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting direction: %s", err), "(Data) ibm_is_network_acl_rule", "read", "set-direction").GetDiag()
+					}
+					d.Set(isNetworkACLRuleICMP, make([]map[string]int, 0, 0))
+					d.Set(isNetworkACLRuleTCP, make([]map[string]int, 0, 0))
+					d.Set(isNetworkACLRuleUDP, make([]map[string]int, 0, 0))
+					break
+				}
+			}
 		}
 	}
 	return nil

ibm/service/vpc/data_source_ibm_is_network_acl_rules.go

@@ -347,6 +347,25 @@ func networkACLRulesList(context context.Context, d *schema.ResourceData, meta i
 				l[isNetworkACLRuleTCP] = make([]map[string]int, 0, 0)
 				l[isNetworkACLRuleUDP] = make([]map[string]int, 0, 0)
 			}
+		case "*vpcv1.NetworkACLRuleItem":
+			{
+				rulex := rule.(*vpcv1.NetworkACLRuleItem)
+				l[isNwACLRuleId] = *rulex.ID
+				l[isNetworkACLRuleHref] = *rulex.Href
+				l[isNetworkACLRuleProtocol] = *rulex.Protocol
+				if rulex.Before != nil {
+					l[isNwACLRuleBefore] = *rulex.Before.ID
+				}
+				l[isNetworkACLRuleName] = *rulex.Name
+				l[isNetworkACLRuleAction] = *rulex.Action
+				l[isNetworkACLRuleIPVersion] = *rulex.IPVersion
+				l[isNetworkACLRuleSource] = *rulex.Source
+				l[isNetworkACLRuleDestination] = *rulex.Destination
+				l[isNetworkACLRuleDirection] = *rulex.Direction
+				l[isNetworkACLRuleICMP] = make([]map[string]int, 0, 0)
+				l[isNetworkACLRuleTCP] = make([]map[string]int, 0, 0)
+				l[isNetworkACLRuleUDP] = make([]map[string]int, 0, 0)
+			}
 		}
 		rulesInfo = append(rulesInfo, l)
 	}

ibm/service/vpc/data_source_ibm_is_security_group.go

@@ -412,6 +412,39 @@ func securityGroupGet(context context.Context, d *schema.ResourceData, meta inte
 						}
 						rules = append(rules, r)
 					}
+				case "*vpcv1.SecurityGroupRule":
+					{
+						rule := sgrule.(*vpcv1.SecurityGroupRule)
+						r := make(map[string]interface{})
+						r[isSgRuleDirection] = *rule.Direction
+						r[isSgRuleIPVersion] = *rule.IPVersion
+						if rule.Protocol != nil {
+							r[isSgRuleProtocol] = *rule.Protocol
+						}
+						r[isSgRuleID] = *rule.ID
+						remote, ok := rule.Remote.(*vpcv1.SecurityGroupRuleRemote)
+						if ok {
+							if remote != nil && reflect.ValueOf(remote).IsNil() == false {
+								if remote.ID != nil {
+									r[isSgRuleRemote] = remote.ID
+								} else if remote.Address != nil {
+									r[isSgRuleRemote] = remote.Address
+								} else if remote.CIDRBlock != nil {
+									r[isSgRuleRemote] = remote.CIDRBlock
+								}
+							}
+						}
+						local, ok := rule.Local.(*vpcv1.SecurityGroupRuleLocal)
+						if ok {
+							if local != nil && !reflect.ValueOf(local).IsNil() {
+								localList := []map[string]interface{}{}
+								localMap := dataSourceSecurityGroupRuleLocalToMap(local)
+								localList = append(localList, localMap)
+								r["local"] = localList
+							}
+						}
+						rules = append(rules, r)
+					}
 				case "*vpcv1.SecurityGroupRuleProtocolIcmptcpudp":
 					{
 						rule := sgrule.(*vpcv1.SecurityGroupRuleProtocolIcmptcpudp)

ibm/service/vpc/data_source_ibm_is_security_group_rule.go

@@ -214,6 +214,41 @@ func dataSourceIBMIsSecurityGroupRuleRead(context context.Context, d *schema.Res
 	case "*vpcv1.SecurityGroupRuleProtocolIndividual":
 		{
 			securityGroupRule := securityGroupRuleIntf.(*vpcv1.SecurityGroupRuleProtocolIndividual)
+			d.SetId(*securityGroupRule.ID)
+			if err = d.Set("direction", securityGroupRule.Direction); err != nil {
+				return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting direction: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-direction").GetDiag()
+			}
+			if err = d.Set("href", securityGroupRule.Href); err != nil {
+				return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting href: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-href").GetDiag()
+			}
+			if err = d.Set("ip_version", securityGroupRule.IPVersion); err != nil {
+				return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting ip_version: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-ip_version").GetDiag()
+			}
+			if err = d.Set("protocol", securityGroupRule.Protocol); err != nil {
+				return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting protocol: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-protocol").GetDiag()
+			}
+			if securityGroupRule.Remote != nil {
+				securityGroupRuleRemote, err := dataSourceSecurityGroupRuleFlattenRemote(securityGroupRule.Remote)
+				if err != nil {
+					return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_security_group_rule", "read", "remote-to-map").GetDiag()
+				}
+				if err = d.Set("remote", securityGroupRuleRemote); err != nil {
+					return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting remote: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-remote").GetDiag()
+				}
+			}
+			if securityGroupRule.Local != nil {
+				securityGroupRuleLocal, err := dataSourceSecurityGroupRuleFlattenLocal(securityGroupRule.Local)
+				if err != nil {
+					return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_security_group_rule", "read", "local-to-map").GetDiag()
+				}
+				if err = d.Set("local", securityGroupRuleLocal); err != nil {
+					return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting local: %s", err), "(Data) ibm_is_security_group_rule", "read", "set-local").GetDiag()
+				}
+			}
+		}
+	case "*vpcv1.SecurityGroupRule":
+		{
+			securityGroupRule := securityGroupRuleIntf.(*vpcv1.SecurityGroupRule)
 
 			d.SetId(*securityGroupRule.ID)
 			if err = d.Set("direction", securityGroupRule.Direction); err != nil {

ibm/service/vpc/data_source_ibm_is_security_group_rules.go

@@ -265,6 +265,30 @@ func dataSourceIBMIsSecurityGroupRulesRead(context context.Context, d *schema.Re
 					l["local"] = localList
 				}
 
+			}
+		case "*vpcv1.SecurityGroupRule":
+			{
+				rulex := rule.(*vpcv1.SecurityGroupRule)
+				l["direction"] = *rulex.Direction
+				l["href"] = *rulex.Href
+				l["id"] = *rulex.ID
+				l["ip_version"] = *rulex.IPVersion
+				l["protocol"] = *rulex.Protocol
+				// nested map for remote.
+				if rulex.Remote != nil {
+					remoteList := []map[string]interface{}{}
+					remoteMap := dataSourceSecurityGroupRuleRemoteToMap(rulex.Remote.(*vpcv1.SecurityGroupRuleRemote))
+					remoteList = append(remoteList, remoteMap)
+					l["remote"] = remoteList
+				}
+				// nested map for local.
+				if rulex.Local != nil {
+					localList := []map[string]interface{}{}
+					localMap := dataSourceSecurityGroupRuleLocalToMap(rulex.Local.(*vpcv1.SecurityGroupRuleLocal))
+					localList = append(localList, localMap)
+					l["local"] = localList
+				}
+
 			}
 		case "*vpcv1.SecurityGroupRuleSecurityGroupRuleProtocolIcmp":
 			{

ibm/service/vpc/data_source_ibm_is_security_groups.go

@@ -581,6 +581,37 @@ func dataSourceSecurityGroupCollectionSecurityGroupsRulesToMap(rulesItem vpcv1.S
 				resultMap["local"] = localList
 			}
 		}
+	case "*vpcv1.SecurityGroupRule":
+		{
+			securityGroupRule := rulesItem.(*vpcv1.SecurityGroupRule)
+			if securityGroupRule.ID != nil {
+				resultMap["id"] = securityGroupRule.ID
+			}
+			if securityGroupRule.Direction != nil {
+				resultMap["direction"] = securityGroupRule.Direction
+			}
+			if securityGroupRule.Href != nil {
+				resultMap["href"] = securityGroupRule.Href
+			}
+			if securityGroupRule.IPVersion != nil {
+				resultMap["ip_version"] = securityGroupRule.IPVersion
+			}
+			if securityGroupRule.Protocol != nil {
+				resultMap["protocol"] = securityGroupRule.Protocol
+			}
+			if securityGroupRule.Remote != nil {
+				remoteList := []map[string]interface{}{}
+				remoteMap := dataSourceSecurityGroupsRemoteToMap(*securityGroupRule.Remote.(*vpcv1.SecurityGroupRuleRemote))
+				remoteList = append(remoteList, remoteMap)
+				resultMap["remote"] = remoteList
+			}
+			if securityGroupRule.Local != nil {
+				localList := []map[string]interface{}{}
+				localMap := dataSourceSecurityGroupsLocalToMap(*securityGroupRule.Local.(*vpcv1.SecurityGroupRuleLocal))
+				localList = append(localList, localMap)
+				resultMap["local"] = localList
+			}
+		}
 	case "*vpcv1.SecurityGroupRuleSecurityGroupRuleProtocolIcmp":
 		{
 			securityGroupRule := rulesItem.(*vpcv1.SecurityGroupRuleSecurityGroupRuleProtocolIcmp)

ibm/service/vpc/data_source_ibm_is_vpc.go

@@ -1027,6 +1027,30 @@ func setVpcDetails(context context.Context, d *schema.ResourceData, vpc *vpcv1.V
 						}
 						rules = append(rules, r)
 					}
+				case "*vpcv1.SecurityGroupRule":
+					{
+						rule := sgrule.(*vpcv1.SecurityGroupRule)
+						r := make(map[string]interface{})
+						r[isVPCSecurityGroupRuleDirection] = *rule.Direction
+						r[isVPCSecurityGroupRuleIPVersion] = *rule.IPVersion
+						if rule.Protocol != nil {
+							r[isVPCSecurityGroupRuleProtocol] = *rule.Protocol
+						}
+						r[isVPCSecurityGroupRuleID] = *rule.ID
+						remote, ok := rule.Remote.(*vpcv1.SecurityGroupRuleRemote)
+						if ok {
+							if remote != nil && reflect.ValueOf(remote).IsNil() == false {
+								if remote.ID != nil {
+									r[isVPCSecurityGroupRuleRemote] = remote.ID
+								} else if remote.Address != nil {
+									r[isVPCSecurityGroupRuleRemote] = remote.Address
+								} else if remote.CIDRBlock != nil {
+									r[isVPCSecurityGroupRuleRemote] = remote.CIDRBlock
+								}
+							}
+						}
+						rules = append(rules, r)
+					}
 
 				case "*vpcv1.SecurityGroupRuleSecurityGroupRuleProtocolTcpudp":
 					{

ibm/service/vpc/data_source_ibm_is_vpcs.go

@@ -905,6 +905,30 @@ func dataSourceIBMISVPCListRead(context context.Context, d *schema.ResourceData,
 							}
 							rules = append(rules, r)
 						}
+					case "*vpcv1.SecurityGroupRule":
+						{
+							rule := sgrule.(*vpcv1.SecurityGroupRule)
+							r := make(map[string]interface{})
+							r[isVPCSecurityGroupRuleDirection] = *rule.Direction
+							r[isVPCSecurityGroupRuleIPVersion] = *rule.IPVersion
+							if rule.Protocol != nil {
+								r[isVPCSecurityGroupRuleProtocol] = *rule.Protocol
+							}
+							r[isVPCSecurityGroupRuleID] = *rule.ID
+							remote, ok := rule.Remote.(*vpcv1.SecurityGroupRuleRemote)
+							if ok {
+								if remote != nil && reflect.ValueOf(remote).IsNil() == false {
+									if remote.ID != nil {
+										r[isVPCSecurityGroupRuleRemote] = remote.ID
+									} else if remote.Address != nil {
+										r[isVPCSecurityGroupRuleRemote] = remote.Address
+									} else if remote.CIDRBlock != nil {
+										r[isVPCSecurityGroupRuleRemote] = remote.CIDRBlock
+									}
+								}
+							}
+							rules = append(rules, r)
+						}
 
 					case "*vpcv1.SecurityGroupRuleSecurityGroupRuleProtocolTcpudp":
 						{