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())