Map flavor name not found Internal error to the ResourceExhausted MCM error code (gardener#350)

* Map flavor name not found Internal error to the ResourceExhausted MCM error

* Fix errors and extend tests

* Run make generate

* Fix errors and enhance tests

* Add additional tests for error code mapping

* Rename driver_test to utils_test

---------

Co-authored-by: Prashant Tak <prashant.tak@sap.com>

Author: ririko-nakamura

pkg/driver/executor/errors.go

@@ -24,3 +24,14 @@ var (
 	// OpenStack resources. In case this case, where a unique ID could not be determined an ErrMultipleFound is returned.
 	ErrMultipleFound = fmt.Errorf("multiple resources found")
 )
+
+// ErrFlavorNotFound is returned when there is no flavor can be matched with the specified flavor name.
+// It can happen when certain flavor is not available in specified region and needs to be treated as ResourceExhausted
+// to allow fallback to other flavors.
+type ErrFlavorNotFound struct {
+	Flavor string
+}
+
+func (e ErrFlavorNotFound) Error() string {
+	return fmt.Sprintf("Unable to find flavor with name %s", e.Flavor)
+}

pkg/driver/executor/executor.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/volumes"
 	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/keypairs"
 	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/servers"
@@ -276,7 +277,12 @@ func (ex *Executor) deployServer(ctx context.Context, machineName string, userDa
 	}
 	flavorRef, err := ex.Compute.FlavorIDFromName(ctx, flavorName)
 	if err != nil {
-		return nil, fmt.Errorf("error resolving flavor ID from flavor name %q: %v", imageName, err)
+		switch err.(type) {
+		case gophercloud.ErrResourceNotFound:
+			return nil, fmt.Errorf("error resolving flavor ID from flavor name %q: %w", flavorName, ErrFlavorNotFound{Flavor: flavorName})
+		default:
+			return nil, fmt.Errorf("error resolving flavor ID from flavor name %q: %v", flavorName, err)
+		}
 	}
 
 	createOpts := &servers.CreateOpts{

pkg/driver/executor/executor_test.go

@@ -209,6 +209,24 @@ var _ = Describe("Executor", func() {
 			Expect(server.ProviderID).To(Equal(encodeProviderID(region, serverID)))
 		})
 
+		It("should raise a ErrResourceNotFound error when called with a missing flavor", func() {
+			ex := &Executor{
+				Compute: compute,
+				Network: network,
+				Config:  cfg,
+			}
+
+			compute.EXPECT().ListServers(ctx, &servers.ListOpts{Name: machineName}).Return([]servers.Server{}, nil)
+			compute.EXPECT().ImageIDFromName(ctx, imageName).Return(images.Image{ID: "imageID"}, nil)
+			compute.EXPECT().FlavorIDFromName(ctx, flavorName).Return(flavorName, gophercloud.ErrResourceNotFound{Name: flavorName, ResourceType: "flavor"})
+			compute.EXPECT().ListServers(ctx, &servers.ListOpts{Name: machineName}).Return([]servers.Server{}, nil)
+
+			_, err := ex.CreateMachine(ctx, machineName, nil)
+			Expect(err).To(HaveOccurred())
+			Expect(errors.Is(err, ErrFlavorNotFound{Flavor: "flavor"})).To(BeTrue())
+			Expect(errors.As(err, &ErrFlavorNotFound{})).To(BeTrue())
+		})
+
 		It("should delete the server on failure", func() {
 			ex := &Executor{
 				Compute: compute,

pkg/driver/utils.go

@@ -63,6 +63,10 @@ func mapErrorToCode(err error) codes.Code {
 		return codes.PermissionDenied
 	}
 
+	if errors.As(err, &executor.ErrFlavorNotFound{}) {
+		return codes.ResourceExhausted
+	}
+
 	return mapErrorMessageToCode(err)
 }
 

pkg/driver/utils_test.go

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and Gardener contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package driver
+
+import (
+	"fmt"
+
+	"github.com/gardener/machine-controller-manager/pkg/util/provider/machinecodes/codes"
+	"github.com/gardener/machine-controller-manager/pkg/util/provider/machinecodes/status"
+	"github.com/gophercloud/gophercloud/v2"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"github.com/gardener/machine-controller-manager-provider-openstack/pkg/driver/executor"
+)
+
+var _ = Describe("Utils", func() {
+
+	Context("mapErrorToCode", func() {
+		It("should map executor.ErrFlavorNotFound error to ResourceExhausted error code", func() {
+			err1 := executor.ErrFlavorNotFound{}
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.ResourceExhausted))
+		})
+		It("should map executor.ErrFlavorNotFound error with specific flavor to ResourceExhausted error code", func() {
+			err1 := executor.ErrFlavorNotFound{Flavor: "flavor"}
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.ResourceExhausted))
+		})
+		It("should map executor.ErrNotFound error to NotFound error code", func() {
+			err1 := executor.ErrNotFound
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.NotFound))
+		})
+		It("should map gophercloud.ErrResourceNotFound error to Internal error code", func() {
+			err1 := gophercloud.ErrResourceNotFound{}
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.Internal))
+		})
+		It("should map error containing executor.NoValidHost to ResourceExhausted error code", func() {
+			err1 := fmt.Errorf("error: %s", executor.NoValidHost)
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.ResourceExhausted))
+		})
+		It("should map error containing random string to Internal error code", func() {
+			err1 := fmt.Errorf("error: Random provider issue")
+			err2 := status.Error(mapErrorToCode(err1), err1.Error())
+			Expect(err1).To(HaveOccurred())
+			Expect(err2).To(HaveOccurred())
+			Expect(mapErrorToCode(err1)).To(Equal(codes.Internal))
+		})
+	})
+})