Add GetSubnetByFilter

Author: mdbooth

controllers/openstackcluster_controller.go

@@ -446,22 +446,23 @@ func reconcileNetworkComponents(scope scope.Scope, cluster *clusterv1.Cluster, o
 		openStackCluster.Status.Network.Name = networkList[0].Name
 		openStackCluster.Status.Network.Tags = networkList[0].Tags
 
-		subnetOpts := openStackCluster.Spec.Subnet.ToListOpt()
-		subnetOpts.NetworkID = networkList[0].ID
-		subnetList, err := networkingService.GetSubnetsByFilter(&subnetOpts)
-		if err != nil || len(subnetList) == 0 {
-			handleUpdateOSCError(openStackCluster, errors.Errorf("failed to find subnet: %v", err))
-			return errors.Errorf("failed to find subnet: %v", err)
-		}
-		if len(subnetList) > 1 {
-			handleUpdateOSCError(openStackCluster, errors.Errorf("failed to find only one subnet (result: %v): %v", subnetList, err))
-			return errors.Errorf("failed to find only one subnet (result: %v): %v", subnetList, err)
+		subnet, err := networkingService.GetSubnetByFilter(&openStackCluster.Spec.Subnet)
+		if err != nil {
+			err = fmt.Errorf("failed to find subnet: %w", err)
+
+			// Set the cluster to failed if subnet filter is invalid
+			if errors.Is(err, networking.ErrFilterMatch) {
+				handleUpdateOSCError(openStackCluster, err)
+			}
+
+			return err
 		}
+
 		openStackCluster.Status.Network.Subnet = &infrav1.Subnet{
-			ID:   subnetList[0].ID,
-			Name: subnetList[0].Name,
-			CIDR: subnetList[0].CIDR,
-			Tags: subnetList[0].Tags,
+			ID:   subnet.ID,
+			Name: subnet.Name,
+			CIDR: subnet.CIDR,
+			Tags: subnet.Tags,
 		}
 	} else {
 		err := networkingService.ReconcileNetwork(openStackCluster, clusterName)

pkg/cloud/services/networking/network.go

@@ -28,9 +28,37 @@ import (
 	infrav1 "sigs.k8s.io/cluster-api-provider-openstack/api/v1alpha7"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/metrics"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/record"
+	capoerrors "sigs.k8s.io/cluster-api-provider-openstack/pkg/utils/errors"
 	"sigs.k8s.io/cluster-api-provider-openstack/pkg/utils/names"
 )
 
+var (
+	ErrFilterMatch     = fmt.Errorf("filter match error")
+	ErrMultipleMatches = multipleMatchesError{}
+	ErrNoMatches       = noMatchesError{}
+)
+
+type (
+	multipleMatchesError struct{}
+	noMatchesError       struct{}
+)
+
+func (e multipleMatchesError) Error() string {
+	return "filter matched more than one resource"
+}
+
+func (e multipleMatchesError) Is(err error) bool {
+	return err == ErrFilterMatch
+}
+
+func (e noMatchesError) Error() string {
+	return "filter matched no resources"
+}
+
+func (e noMatchesError) Is(err error) bool {
+	return err == ErrFilterMatch
+}
+
 type createOpts struct {
 	AdminStateUp        *bool  `json:"admin_state_up,omitempty"`
 	Name                string `json:"name,omitempty"`
@@ -315,11 +343,36 @@ func (s *Service) GetSubnetsByFilter(opts subnets.ListOptsBuilder) ([]subnets.Su
 		return []subnets.Subnet{}, err
 	}
 	if len(subnetList) == 0 {
-		return nil, fmt.Errorf("no subnets could be found with the filters provided")
+		return nil, ErrNoMatches
 	}
 	return subnetList, nil
 }
 
+// GetSubnetByFilter gets a single subnet specified by the given SubnetFilter.
+// It returns an ErrFilterMatch if no or multiple subnets are found.
+func (s *Service) GetSubnetByFilter(filter *infrav1.SubnetFilter) (*subnets.Subnet, error) {
+	// If the ID is set, we can just get the subnet by ID.
+	if filter.ID != "" {
+		subnet, err := s.client.GetSubnet(filter.ID)
+		if capoerrors.IsNotFound(err) {
+			return nil, ErrNoMatches
+		}
+		return subnet, err
+	}
+
+	subnets, err := s.GetSubnetsByFilter(filter.ToListOpt())
+	if err != nil {
+		return nil, err
+	}
+	if len(subnets) == 0 {
+		return nil, ErrNoMatches
+	}
+	if len(subnets) > 1 {
+		return nil, ErrMultipleMatches
+	}
+	return &subnets[0], nil
+}
+
 func getSubnetName(clusterName string) string {
 	return fmt.Sprintf("%s-cluster-%s", networkPrefix, clusterName)
 }

pkg/cloud/services/networking/router.go

@@ -166,15 +166,11 @@ func (s *Service) setRouterExternalIPs(openStackCluster *infrav1.OpenStackCluste
 	for _, externalRouterIP := range openStackCluster.Spec.ExternalRouterIPs {
 		subnetID := externalRouterIP.Subnet.UUID
 		if subnetID == "" {
-			listOpts := externalRouterIP.Subnet.Filter.ToListOpt()
-			subnetsByFilter, err := s.GetSubnetsByFilter(&listOpts)
+			subnet, err := s.GetSubnetByFilter(&externalRouterIP.Subnet.Filter)
 			if err != nil {
-				return err
+				return fmt.Errorf("failed to get subnet for external router: %w", err)
 			}
-			if len(subnetsByFilter) != 1 {
-				return fmt.Errorf("subnetParam didn't exactly match one subnet")
-			}
-			subnetID = subnetsByFilter[0].ID
+			subnetID = subnet.ID
 		}
 		updateOpts.GatewayInfo.ExternalFixedIPs = append(updateOpts.GatewayInfo.ExternalFixedIPs, routers.ExternalFixedIP{
 			IPAddress: externalRouterIP.FixedIP,