Use pointer to store user limits to allow for unspecified limits.

Author: MirahImage

api/v1beta1/user_types.go

@@ -41,7 +41,7 @@ type UserSpec struct {
 	// the user can create. These limits can be used as guard rails in environments
 	// where applications cannot be trusted and monitored in detail, for example,
 	// when RabbitMQ clusters are offered as a service. See https://www.rabbitmq.com/docs/user-limits.
-	UserLimits UserLimits `json:"limits,omitempty"`
+	UserLimits *UserLimits `json:"limits,omitempty"`
 }
 
 // UserStatus defines the observed state of User.
@@ -67,9 +67,9 @@ type UserTag string
 // when RabbitMQ clusters are offered as a service. See https://www.rabbitmq.com/docs/user-limits.
 type UserLimits struct {
 	// Limits how many connections the user can open.
-	Connections int32 `json:"connections,omitempty"`
+	Connections *int32 `json:"connections,omitempty"`
 	// Limits how many AMQP 0.9.1 channels the user can open.
-	Channels int32 `json:"channels,omitempty"`
+	Channels *int32 `json:"channels,omitempty"`
 }
 
 // +genclient

api/v1beta1/user_types_test.go

@@ -96,6 +96,7 @@ var _ = Describe("user spec", func() {
 		var user User
 		var username string
 		var userLimits UserLimits
+		var connections, channels int32
 
 		JustBeforeEach(func() {
 			user = User{
@@ -107,17 +108,19 @@ var _ = Describe("user spec", func() {
 					RabbitmqClusterReference: RabbitmqClusterReference{
 						Name: "some-cluster",
 					},
-					UserLimits: userLimits,
+					UserLimits: &userLimits,
 				},
 			}
 		})
 
 		When("creating a user with valid limits", func() {
 			BeforeEach(func() {
 				username = "limits-user"
+				connections = 5
+				channels = 10
 				userLimits = UserLimits{
-					Connections: 5,
-					Channels:    10,
+					Connections: &connections,
+					Channels:    &channels,
 				}
 			})
 			It("successfully creates the user", func() {
@@ -130,7 +133,9 @@ var _ = Describe("user spec", func() {
 				Expect(fetchedUser.Spec.RabbitmqClusterReference).To(Equal(RabbitmqClusterReference{
 					Name: "some-cluster",
 				}))
-				Expect(fetchedUser.Spec.UserLimits).To(Equal(UserLimits{Connections: 5, Channels: 10}))
+				Expect(fetchedUser.Spec.UserLimits).NotTo(BeNil())
+				Expect(*fetchedUser.Spec.UserLimits.Connections).To(Equal(connections))
+				Expect(*fetchedUser.Spec.UserLimits.Channels).To(Equal(channels))
 			})
 		})
 	})

api/v1beta1/zz_generated.deepcopy.go

@@ -255,13 +255,5 @@ func (r *UserReconciler) DeleteFunc(ctx context.Context, client rabbitmqclient.C
 	} else if err != nil {
 		return err
 	}
-
-	userLimits := []string{"max-connections", "max-channels"}
-	err = validateResponseForDeletion(client.DeleteUserLimits(user.Status.Username, userLimits))
-	if errors.Is(err, NotFound) {
-		logger.Info("cannot find user limits in rabbitmq server; already deleted", "user", user.Name, "limits", userLimits)
-	} else if err != nil {
-		return err
-	}
 	return nil
 }

controllers/user_controller.go

@@ -34,6 +34,8 @@ var _ = Describe("UserController", func() {
 		managerCancel context.CancelFunc
 		k8sClient     runtimeClient.Client
 		userLimits    topology.UserLimits
+		connections   int32
+		channels      int32
 	)
 
 	BeforeEach(func() {
@@ -92,7 +94,7 @@ var _ = Describe("UserController", func() {
 				RabbitmqClusterReference: topology.RabbitmqClusterReference{
 					Name: "example-rabbit",
 				},
-				UserLimits: userLimits,
+				UserLimits: &userLimits,
 			},
 		}
 	})
@@ -160,9 +162,11 @@ var _ = Describe("UserController", func() {
 		When("the user has limits defined", func() {
 			BeforeEach(func() {
 				userName = "test-user-limits"
+				connections = 5
+				channels = 10
 				userLimits = topology.UserLimits{
-					Connections: 5,
-					Channels:    10,
+					Connections: &connections,
+					Channels:    &channels,
 				}
 				fakeRabbitMQClient.PutUserReturns(&http.Response{
 					Status:     "201 Created",
@@ -195,12 +199,8 @@ var _ = Describe("UserController", func() {
 				By("calling PutUserLimits with the correct user limits")
 				Expect(fakeRabbitMQClient.PutUserLimitsCallCount()).To(BeNumerically(">", 0))
 				_, userLimitsValues := fakeRabbitMQClient.PutUserLimitsArgsForCall(0)
-				connectionLimit, ok := userLimitsValues["max-connections"]
-				Expect(ok).To(BeTrue())
-				Expect(connectionLimit).To(Equal(5))
-				channelLimit, ok := userLimitsValues["max-channels"]
-				Expect(ok).To(BeTrue())
-				Expect(channelLimit).To(Equal(10))
+				Expect(userLimitsValues).To(HaveKeyWithValue("max-connections", int(connections)))
+				Expect(userLimitsValues).To(HaveKeyWithValue("max-channels", (int(channels))))
 			})
 		})
 	})

controllers/user_controller_test.go

@@ -63,13 +63,15 @@ func GenerateUserSettings(credentials *corev1.Secret, tags []topology.UserTag) (
 	}, nil
 }
 
-func GenerateUserLimits(userLimits topology.UserLimits) rabbithole.UserLimitsValues {
+func GenerateUserLimits(userLimits *topology.UserLimits) rabbithole.UserLimitsValues {
 	userLimitsValues := rabbithole.UserLimitsValues{}
-	if userLimits.Connections > 0 {
-		userLimitsValues["max-connections"] = int(userLimits.Connections)
-	}
-	if userLimits.Channels > 0 {
-		userLimitsValues["max-channels"] = int(userLimits.Channels)
+	if userLimits != nil {
+		if userLimits.Connections != nil {
+			userLimitsValues["max-connections"] = int(*userLimits.Connections)
+		}
+		if userLimits.Channels != nil {
+			userLimitsValues["max-channels"] = int(*userLimits.Channels)
+		}
 	}
 	return userLimitsValues
 }

internal/user.go

@@ -65,28 +65,33 @@ var _ = Describe("GenerateUserSettings", func() {
 	})
 
 	When("user limits are provided", func() {
+		var connections, channels int32
+
 		It("uses the limits to generate the expected rabbithole.UserLimits", func() {
-			limits := internal.GenerateUserLimits(topology.UserLimits{
-				Connections: 3,
-				Channels:    7,
+			connections = 3
+			channels = 7
+			limits := internal.GenerateUserLimits(&topology.UserLimits{
+				Connections: &connections,
+				Channels:    &channels,
 			})
-			Expect(limits["max-connections"]).To(Equal(3))
-			Expect(limits["max-channels"]).To(Equal(7))
+			Expect(limits).To(HaveLen(2))
+			Expect(limits).To(HaveKeyWithValue("max-connections", int(connections)))
+			Expect(limits).To(HaveKeyWithValue("max-channels", int(channels)))
 		})
 
 		It("does not create unspecified limits", func() {
-			limits := internal.GenerateUserLimits(topology.UserLimits{
-				Connections: 5,
+			connections = 5
+			limits := internal.GenerateUserLimits(&topology.UserLimits{
+				Connections: &connections,
 			})
-			Expect(limits["max-connections"]).To(Equal(5))
-			_, ok := limits["max-channels"]
-			Expect(ok).To(BeFalse())
+			Expect(limits).To(HaveKeyWithValue("max-connections", int(connections)))
+			Expect(limits).NotTo(HaveKey("max-channels"))
 		})
 	})
 
 	When("no user limits are provided", func() {
 		It("does not specify limits", func() {
-			limits := internal.GenerateUserLimits(topology.UserLimits{})
+			limits := internal.GenerateUserLimits(&topology.UserLimits{})
 			Expect(limits).To(BeEmpty())
 		})
 	})

internal/user_test.go

@@ -396,6 +396,7 @@ var _ = Describe("Users", func() {
 	When("providing user limits", func() {
 		const username = "limits-user"
 		var credentialSecret corev1.Secret
+		var connections, channels int32
 		BeforeEach(func() {
 			credentialSecret = corev1.Secret{
 				ObjectMeta: metav1.ObjectMeta{
@@ -409,6 +410,8 @@ var _ = Describe("Users", func() {
 			}
 			Expect(k8sClient.Create(ctx, &credentialSecret, &client.CreateOptions{})).To(Succeed())
 
+			connections = 4
+			channels = 6
 			user = &topology.User{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      username,
@@ -421,9 +424,9 @@ var _ = Describe("Users", func() {
 					ImportCredentialsSecret: &corev1.LocalObjectReference{
 						Name: credentialSecret.Name,
 					},
-					UserLimits: topology.UserLimits{
-						Connections: 4,
-						Channels:    6,
+					UserLimits: &topology.UserLimits{
+						Connections: &connections,
+						Channels:    &channels,
 					},
 				},
 			}
@@ -446,12 +449,8 @@ var _ = Describe("Users", func() {
 			}, 30, 2).Should(BeNil())
 			Expect(userLimitsInfo).To(HaveLen(1))
 			Expect(userLimitsInfo[0].User).To(Equal(username))
-			connectionLimit, ok := userLimitsInfo[0].Value["max-connections"]
-			Expect(ok).To(BeTrue())
-			Expect(connectionLimit).To(Equal(4))
-			channelLimit, ok := userLimitsInfo[0].Value["max-channels"]
-			Expect(ok).To(BeTrue())
-			Expect(channelLimit).To(Equal(6))
+			Expect(userLimitsInfo[0].Value).To(HaveKeyWithValue("max-connections", int(connections)))
+			Expect(userLimitsInfo[0].Value).To(HaveKeyWithValue("max-channels", int(channels)))
 
 			By("deleting user")
 			Expect(k8sClient.Delete(ctx, user)).To(Succeed())