fix

Author: olasaadi99

pkg/vpcmodel/explainabilityConnectivity.go

@@ -184,7 +184,7 @@ func (details *rulesAndConnDetails) computeRoutersAndFilters(c *VPCConfig) (err
 		// RoutingResources are computed by the parser for []Nodes of the VPC,
 		src := singleSrcDstDetails.src
 		dst := singleSrcDstDetails.dst
-		singleSrcDstDetails.loadBalancerRule = getLoadBalancerRule(c, src, dst)
+		singleSrcDstDetails.loadBalancerRule = c.getLoadBalancerRule(src, dst)
 		singleSrcDstDetails.privateSubnetRule = getPrivateSubnetRule(src, dst)
 		if src.IsInternal() && dst.IsInternal() { // internal (including cross vpcs)
 			singleSrcDstDetails.crossVpcRouter, _, err = c.getRoutingResource(src, dst)

pkg/vpcmodel/explainabilityInput.go

@@ -298,15 +298,15 @@ func getSrcOrDstInputNode(c *VPCConfig, name, srcOrDst string) (nodes []Node,
 func getNodesFromInputString(c *VPCConfig, cidrOrName string) (nodes []Node,
 	errType int, err error) {
 	// 1. cidrOrName references endpoint
-	endpoint, errType1, err1 := getNodesOfEndpoint(c, cidrOrName)
+	endpoint, errType1, err1 := c.getNodesOfEndpoint(cidrOrName)
 	if err1 != nil {
 		return nil, errType1, err1
 	}
 	if endpoint != nil {
 		return endpoint, noErr, nil
 	}
 	// 2. cidrOrName references subnet
-	subnetEndpoints, err2 := getNodesOfSubnet(c, cidrOrName)
+	subnetEndpoints, err2 := c.getNodesOfSubnet(cidrOrName)
 	if err2 != nil {
 		return nil, noConnectedEndpoints, err2
 	}
@@ -332,7 +332,7 @@ func getNodesFromInputString(c *VPCConfig, cidrOrName string) (nodes []Node,
 // note: in case there are two subnets of the same name, or a subnet and a vsi, we take the first one
 // using the same name is a bad practice but its not npGuard's responsibility to guard.
 // in this case the user may refer to the exact cidr instead of the name
-func getNodesOfSubnet(c *VPCConfig, name string) ([]Node, error) {
+func (c *VPCConfig) getNodesOfSubnet(name string) ([]Node, error) {
 	inputSubnet, inputVpc := getResourceAndVpcNames(name)
 	var foundSubnet Subnet
 	for _, subnet := range c.Subnets {
@@ -353,7 +353,7 @@ func getNodesOfSubnet(c *VPCConfig, name string) ([]Node, error) {
 
 // getNodesOfEndpoint gets a string name or UID of an endpoint (e.g. VSI), and
 // returns the list of all nodes within this endpoint
-func getNodesOfEndpoint(c *VPCConfig, name string) ([]Node, int, error) {
+func (c *VPCConfig) getNodesOfEndpoint(name string) ([]Node, int, error) {
 	var nodeSetOfEndpoint NodeSet
 	uid := name // uid specified - vpc prefix is not relevant and uid may contain the deliminator "/"
 	// endpoint name may be prefixed by vpc name

pkg/vpcmodel/nodesConnectivity.go

@@ -34,11 +34,11 @@ func (c *VPCConfig) GetVPCNetworkConnectivity(lbAbstraction bool, groupingType i
 		if !node.IsInternal() {
 			continue
 		}
-		allIngressAllowedConns, ingressAllowedConnsPerLayer, err1 := getAllowedConnsPerDirection(c, true, node)
+		allIngressAllowedConns, ingressAllowedConnsPerLayer, err1 := c.getAllowedConnsPerDirection(true, node)
 		if err1 != nil {
 			return nil, err1
 		}
-		allEgressAllowedConns, egressAllowedConnsPerLayer, err2 := getAllowedConnsPerDirection(c, false, node)
+		allEgressAllowedConns, egressAllowedConnsPerLayer, err2 := c.getAllowedConnsPerDirection(false, node)
 		if err2 != nil {
 			return nil, err2
 		}
@@ -70,7 +70,7 @@ func (c *VPCConfig) GetVPCNetworkConnectivity(lbAbstraction bool, groupingType i
 	return res, err
 }
 
-func getLoadBalancerRule(c *VPCConfig, src, dst Node) LoadBalancerRule {
+func (c *VPCConfig) getLoadBalancerRule(src, dst Node) LoadBalancerRule {
 	for _, lb := range c.LoadBalancers {
 		if rule := lb.GetLoadBalancerRule(src, dst); rule != nil {
 			return rule
@@ -91,7 +91,7 @@ func getPrivateSubnetRule(src, dst Node) PrivateSubnetRule {
 
 // getNonFilterNonRouterRulesConn() return the connectivity of all rules that are not part of the filters and routers.
 func getNonFilterNonRouterRulesConn(c *VPCConfig, src, dst Node, isIngress bool) *netset.TransportSet {
-	loadBalancerRule := getLoadBalancerRule(c, src, dst)
+	loadBalancerRule := c.getLoadBalancerRule(src, dst)
 	if loadBalancerRule != nil && loadBalancerRule.Deny(isIngress) {
 		return NoConns()
 	}
@@ -123,7 +123,7 @@ func updatePerLayerRes(res map[string]map[Node]*netset.TransportSet, layer strin
 
 // getAllowedConnsPerDirection returns: (1) map of allowed (ingress or egress) connectivity for capturedNode, considering
 // all relevant resources (nacl/sg/fip/pgw) , and (2) similar map per separated layers only (nacl/sg)
-func getAllowedConnsPerDirection(c *VPCConfig, isIngress bool, capturedNode Node) (
+func (c *VPCConfig) getAllowedConnsPerDirection(isIngress bool, capturedNode Node) (
 	allLayersRes map[Node]*netset.TransportSet, // result considering all layers
 	perLayerRes map[string]map[Node]*netset.TransportSet, // result separated per layer
 	err error,

pkg/vpcmodel/output.go

@@ -97,7 +97,7 @@ func NewOutputGenerator(cConfigs *MultipleVPCConfigs, groupingType int, uc Outpu
 			}
 		case AllSubnets:
 			for i, vpcConfig := range cConfigs.Configs() {
-				subnetsConn, err := GetSubnetsConnectivity(vpcConfig, true, groupingType)
+				subnetsConn, err := vpcConfig.GetSubnetsConnectivity(true, groupingType)
 				if err != nil {
 					return nil, err
 				}

pkg/vpcmodel/semanticDiff.go

@@ -117,7 +117,7 @@ func (configs configsForDiff) GetDiff() (*diffBetweenCfgs, error) {
 func getAllowedResponsiveConnections(c *VPCConfig,
 	diffAnalysis diffAnalysisType) (responsiveConnectivityMap GeneralResponsiveConnectivityMap, err error) {
 	if diffAnalysis == Subnets {
-		subnetsConn, err := GetSubnetsConnectivity(c, true, NoGroupingNoConsistencyEdges)
+		subnetsConn, err := c.GetSubnetsConnectivity(true, NoGroupingNoConsistencyEdges)
 		if err != nil {
 			return nil, err
 		}

pkg/vpcmodel/subnetsConnectivity.go

@@ -71,7 +71,7 @@ func (v *VPCsubnetConnectivity) printAllowedConns(c *VPCConfig) {
 	}
 }
 
-func ipblockToNamedResourcesInConfig(c *VPCConfig, ipb *netset.IPBlock, excludeExternalNodes bool) ([]VPCResourceIntf, error) {
+func (c *VPCConfig) ipblockToNamedResourcesInConfig(ipb *netset.IPBlock, excludeExternalNodes bool) ([]VPCResourceIntf, error) {
 	res := []VPCResourceIntf{}
 
 	// consider subnets
@@ -116,7 +116,7 @@ func convertIPbasedToSubnetBasedResult(c *VPCConfig, ipconn *IPbasedConnectivity
 
 	for ipb, conn := range ipconn.IngressAllowedConns {
 		// PGW does not allow ingress traffic but the ingress is required for the responsive computation
-		if namedResources, err := ipblockToNamedResourcesInConfig(c, ipb, excludeExternalNodes); err == nil {
+		if namedResources, err := c.ipblockToNamedResourcesInConfig(ipb, excludeExternalNodes); err == nil {
 			for _, n := range namedResources {
 				res.IngressAllowedConns[n] = conn
 			}
@@ -127,7 +127,7 @@ func convertIPbasedToSubnetBasedResult(c *VPCConfig, ipconn *IPbasedConnectivity
 
 	// egress traffic to external nodes may be enabled by a public gateway
 	for ipb, conn := range ipconn.EgressAllowedConns {
-		if namedResources, err := ipblockToNamedResourcesInConfig(c, ipb, excludeExternalNodes); err == nil {
+		if namedResources, err := c.ipblockToNamedResourcesInConfig(ipb, excludeExternalNodes); err == nil {
 			for _, n := range namedResources {
 				res.EgressAllowedConns[n] = conn
 			}
@@ -172,7 +172,7 @@ func getSubnetsWithPGW(c *VPCConfig) map[string]bool {
 }
 
 // the main function to compute connectivity per subnet based on resources that capture subnets, such as nacl, pgw, tgw, routing-tables
-func GetSubnetsConnectivity(c *VPCConfig, includePGW bool, groupingType int) (*VPCsubnetConnectivity, error) {
+func (c *VPCConfig) GetSubnetsConnectivity(includePGW bool, groupingType int) (*VPCsubnetConnectivity, error) {
 	var subnetsConnectivityFromACLresources map[string]*IPbasedConnectivityResult
 	var err error
 	for _, fl := range c.FilterResources {
@@ -351,7 +351,7 @@ func (v *VPCsubnetConnectivity) computeResponsiveConnections(allowedConnsCombine
 // GetConnectivityOutputPerEachSubnetSeparately returns string results of connectivity analysis per
 // single subnet with its attached nacl, separately per subnet - useful to get understanding of the
 // connectivity implied from nacl configuration applied on a certain subnet in the vpc
-func GetConnectivityOutputPerEachSubnetSeparately(c *VPCConfig) string {
+func (c *VPCConfig) GetConnectivityOutputPerEachSubnetSeparately() string {
 	// iterate over all subnets, collect all outputs per subnet connectivity
 	for _, r := range c.FilterResources {
 		if r.Kind() == NaclLayer {

pkg/vpcmodel/textOutput.go

@@ -78,7 +78,7 @@ func (t *TextOutputFormatter) WriteOutput(c1, c2 *VPCConfig,
 		out += subnetsConn.GroupedConnectivity.String(c1)
 		hasStatelessConns = subnetsConn.GroupedConnectivity.hasStatelessConns()
 	case SingleSubnet:
-		out += GetConnectivityOutputPerEachSubnetSeparately(c1)
+		out += c1.GetConnectivityOutputPerEachSubnetSeparately()
 	case SubnetsDiff, EndpointsDiff:
 		diffOut := cfgsDiff.String()
 		if diffOut != "" {