From 01bc0bdebd14cae6adc68f23ac6533dc39dbdaf4 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 11:02:23 +0200 Subject: [PATCH 1/8] feat: Add Role::fixed_replica_count function --- crates/stackable-operator/CHANGELOG.md | 2 + crates/stackable-operator/src/role_utils.rs | 98 +++++++++++++++++++++ 2 files changed, 100 insertions(+) diff --git a/crates/stackable-operator/CHANGELOG.md b/crates/stackable-operator/CHANGELOG.md index f8d19421a..027cb6966 100644 --- a/crates/stackable-operator/CHANGELOG.md +++ b/crates/stackable-operator/CHANGELOG.md @@ -8,8 +8,10 @@ All notable changes to this project will be documented in this file. - Support the annotation `secrets.stackable.tech/backend.autotls.cert.domain-components-in-subject-dn` in the `SecretOperatorVolumeSourceBuilder` ([#1209]). +- Add `Role::fixed_replica_count` function that returns (optionally) the number of fixed replicas ([#XXXX]). [#1209]: https://github.com/stackabletech/operator-rs/pull/1209 +[#XXXX]: https://github.com/stackabletech/operator-rs/pull/XXXX ## [0.113.0] - 2026-06-22 diff --git a/crates/stackable-operator/src/role_utils.rs b/crates/stackable-operator/src/role_utils.rs index 511b84b34..542731c8d 100644 --- a/crates/stackable-operator/src/role_utils.rs +++ b/crates/stackable-operator/src/role_utils.rs @@ -403,6 +403,39 @@ where } } +impl + Role +where + RoleConfig: Default + JsonSchema + Serialize, + CommonConfig: Default + JsonSchema + Serialize, + ConfigOverrides: Default + JsonSchema + Serialize, +{ + /// Returns [`Some`] in case the number of nodes is hard-coded to a certain value. + /// + /// This is the case when all `replicas` are set to [`Some`], in which case they are simply + /// summed. + /// + /// The argument `treat_zero_as_none` is a safety mechanism, which allows the caller to decide + /// if an explicit replica count of `0` should be treated as [`None`]. It also means that + /// [`None`] is returned in case no roleGroups are configured at all. + pub fn fixed_replica_count(&self, treat_zero_as_none: bool) -> Option { + // An empty role has no fixed replica count when zeros are treated as None. + if treat_zero_as_none && self.role_groups.is_empty() { + return None; + } + + self.role_groups + .values() + .map(|rg| match rg.replicas { + None => None, + Some(0) if treat_zero_as_none => None, + // The individual replicas are [`u16`]s, so a [`u32`] sum has plenty of space. + Some(replicas) => Some(u32::from(replicas)), + }) + .sum() + } +} + impl Role where @@ -654,4 +687,69 @@ mod tests { ] ); } + + #[test] + fn fixed_replica_count_sums_all_set_replicas() { + let role = construct_role_with_replicas([Some(3), Some(2), Some(5)]); + + assert_eq!(role.fixed_replica_count(false), Some(10)); + assert_eq!(role.fixed_replica_count(true), Some(10)); + } + + #[test] + fn fixed_replica_count_is_none_if_any_replica_is_unset() { + let role = construct_role_with_replicas([Some(3), None, Some(2)]); + + assert_eq!(role.fixed_replica_count(false), None); + assert_eq!(role.fixed_replica_count(true), None); + } + + #[test] + fn fixed_replica_count_treats_zero_according_to_flag() { + let role = construct_role_with_replicas([Some(3), Some(0)]); + + assert_eq!(role.fixed_replica_count(false), Some(3)); + // With treat_zero_as_none the zero turns the whole count into None. + assert_eq!(role.fixed_replica_count(true), None); + } + + #[test] + fn fixed_replica_count_of_single_zero_role_group() { + let role = construct_role_with_replicas([Some(0)]); + + assert_eq!(role.fixed_replica_count(false), Some(0)); + assert_eq!(role.fixed_replica_count(true), None); + } + + #[test] + fn fixed_replica_count_of_role_without_role_groups_is_zero() { + let role = construct_role_with_replicas(vec![]); + + assert_eq!(role.fixed_replica_count(false), Some(0)); + assert_eq!(role.fixed_replica_count(true), None); + } + + /// Builds a [`Role`] with one role group per passed `replicas` entry, so tests only need to + /// care about the replica counts that [`Role::fixed_replica_count`] operates on. + fn construct_role_with_replicas( + replicas: impl IntoIterator>, + ) -> Role<(), EmptyConfigOverrides, GenericRoleConfig, GenericCommonConfig> { + Role { + config: CommonConfiguration::default(), + role_config: GenericRoleConfig::default(), + role_groups: replicas + .into_iter() + .enumerate() + .map(|(index, replicas)| { + ( + format!("role-group-{index}"), + RoleGroup { + config: CommonConfiguration::default(), + replicas, + }, + ) + }) + .collect(), + } + } } From bdeb12fab9f7f23c59a091fcacca8139f5c955b9 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 11:17:50 +0200 Subject: [PATCH 2/8] Add Role::estimated_replica_count as well --- crates/stackable-operator/CHANGELOG.md | 2 +- crates/stackable-operator/src/role_utils.rs | 27 +++++++++++++++++---- 2 files changed, 23 insertions(+), 6 deletions(-) diff --git a/crates/stackable-operator/CHANGELOG.md b/crates/stackable-operator/CHANGELOG.md index 027cb6966..9bd631ea6 100644 --- a/crates/stackable-operator/CHANGELOG.md +++ b/crates/stackable-operator/CHANGELOG.md @@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file. - Support the annotation `secrets.stackable.tech/backend.autotls.cert.domain-components-in-subject-dn` in the `SecretOperatorVolumeSourceBuilder` ([#1209]). -- Add `Role::fixed_replica_count` function that returns (optionally) the number of fixed replicas ([#XXXX]). +- Add `Role::fixed_replica_count` and `Role::estimated_replica_count` helper functions ([#XXXX]). [#1209]: https://github.com/stackabletech/operator-rs/pull/1209 [#XXXX]: https://github.com/stackabletech/operator-rs/pull/XXXX diff --git a/crates/stackable-operator/src/role_utils.rs b/crates/stackable-operator/src/role_utils.rs index 542731c8d..8d029f166 100644 --- a/crates/stackable-operator/src/role_utils.rs +++ b/crates/stackable-operator/src/role_utils.rs @@ -434,6 +434,18 @@ where }) .sum() } + + /// Returns the estimated total number of replicas across all role groups. + /// + /// Unlike [`Self::fixed_replica_count`], this always returns a value: a role group with an unset + /// (i.e. [`None`]) replica count is assumed to run a single replica. Use this when a best-effort + /// estimate is needed even though the exact number of replicas is not hard-coded. + pub fn estimated_replica_count(&self) -> u32 { + self.role_groups + .values() + .map(|rg| u32::from(rg.replicas.unwrap_or(1))) + .sum() + } } impl @@ -689,44 +701,49 @@ mod tests { } #[test] - fn fixed_replica_count_sums_all_set_replicas() { + fn replica_counts_with_all_replicas_set() { let role = construct_role_with_replicas([Some(3), Some(2), Some(5)]); assert_eq!(role.fixed_replica_count(false), Some(10)); assert_eq!(role.fixed_replica_count(true), Some(10)); + assert_eq!(role.estimated_replica_count(), 10); } #[test] - fn fixed_replica_count_is_none_if_any_replica_is_unset() { + fn replica_counts_with_one_replica_unset() { let role = construct_role_with_replicas([Some(3), None, Some(2)]); assert_eq!(role.fixed_replica_count(false), None); assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.estimated_replica_count(), 6); } #[test] - fn fixed_replica_count_treats_zero_according_to_flag() { + fn replica_counts_with_a_zero_replica() { let role = construct_role_with_replicas([Some(3), Some(0)]); assert_eq!(role.fixed_replica_count(false), Some(3)); // With treat_zero_as_none the zero turns the whole count into None. assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.estimated_replica_count(), 3); } #[test] - fn fixed_replica_count_of_single_zero_role_group() { + fn replica_counts_with_a_single_zero_role_group() { let role = construct_role_with_replicas([Some(0)]); assert_eq!(role.fixed_replica_count(false), Some(0)); assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.estimated_replica_count(), 0); } #[test] - fn fixed_replica_count_of_role_without_role_groups_is_zero() { + fn replica_counts_without_role_groups() { let role = construct_role_with_replicas(vec![]); assert_eq!(role.fixed_replica_count(false), Some(0)); assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.estimated_replica_count(), 0); } /// Builds a [`Role`] with one role group per passed `replicas` entry, so tests only need to From 4ed5105a515c7501c824f4824a06cecf3dcf8060 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 11:18:42 +0200 Subject: [PATCH 3/8] changelog --- crates/stackable-operator/CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/stackable-operator/CHANGELOG.md b/crates/stackable-operator/CHANGELOG.md index 9bd631ea6..ce1d4e734 100644 --- a/crates/stackable-operator/CHANGELOG.md +++ b/crates/stackable-operator/CHANGELOG.md @@ -8,10 +8,10 @@ All notable changes to this project will be documented in this file. - Support the annotation `secrets.stackable.tech/backend.autotls.cert.domain-components-in-subject-dn` in the `SecretOperatorVolumeSourceBuilder` ([#1209]). -- Add `Role::fixed_replica_count` and `Role::estimated_replica_count` helper functions ([#XXXX]). +- Add `Role::fixed_replica_count` and `Role::estimated_replica_count` helper functions ([#1241]). [#1209]: https://github.com/stackabletech/operator-rs/pull/1209 -[#XXXX]: https://github.com/stackabletech/operator-rs/pull/XXXX +[#1241]: https://github.com/stackabletech/operator-rs/pull/1241 ## [0.113.0] - 2026-06-22 From df8f5cc27ebde229153da3bfc640f26fd443818f Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 12:25:24 +0200 Subject: [PATCH 4/8] Update crates/stackable-operator/src/role_utils.rs Co-authored-by: Techassi --- crates/stackable-operator/src/role_utils.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/stackable-operator/src/role_utils.rs b/crates/stackable-operator/src/role_utils.rs index 8d029f166..053a17bbe 100644 --- a/crates/stackable-operator/src/role_utils.rs +++ b/crates/stackable-operator/src/role_utils.rs @@ -410,7 +410,7 @@ where CommonConfig: Default + JsonSchema + Serialize, ConfigOverrides: Default + JsonSchema + Serialize, { - /// Returns [`Some`] in case the number of nodes is hard-coded to a certain value. + /// Returns [`Some`] in case the number of replicas is hard-coded to a certain value. /// /// This is the case when all `replicas` are set to [`Some`], in which case they are simply /// summed. From d3cc0a2121ba7653ac6c23b6e4c63b5ddd37dc67 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 12:54:58 +0200 Subject: [PATCH 5/8] refactor: Use enum instead of bool --- crates/stackable-operator/src/role_utils.rs | 42 +++++++++++++-------- 1 file changed, 27 insertions(+), 15 deletions(-) diff --git a/crates/stackable-operator/src/role_utils.rs b/crates/stackable-operator/src/role_utils.rs index 053a17bbe..63fc027ff 100644 --- a/crates/stackable-operator/src/role_utils.rs +++ b/crates/stackable-operator/src/role_utils.rs @@ -415,12 +415,15 @@ where /// This is the case when all `replicas` are set to [`Some`], in which case they are simply /// summed. /// - /// The argument `treat_zero_as_none` is a safety mechanism, which allows the caller to decide - /// if an explicit replica count of `0` should be treated as [`None`]. It also means that + /// The argument `zero_replicas_counting` is a safety mechanism, which allows the caller to + /// decide if an explicit replica count of `0` should be treated as [`None`]. It also means that /// [`None`] is returned in case no roleGroups are configured at all. - pub fn fixed_replica_count(&self, treat_zero_as_none: bool) -> Option { + pub fn fixed_replica_count( + &self, + zero_replicas_counting: ZeroReplicasCounting, + ) -> Option { // An empty role has no fixed replica count when zeros are treated as None. - if treat_zero_as_none && self.role_groups.is_empty() { + if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone && self.role_groups.is_empty() { return None; } @@ -428,7 +431,7 @@ where .values() .map(|rg| match rg.replicas { None => None, - Some(0) if treat_zero_as_none => None, + Some(0) if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone => None, // The individual replicas are [`u16`]s, so a [`u32`] sum has plenty of space. Some(replicas) => Some(u32::from(replicas)), }) @@ -448,6 +451,15 @@ where } } +/// How explicit zero (`0`) replicas on a role group should be counted +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum ZeroReplicasCounting { + /// Treat them as what they are: `Some(0)`. + TreatAsZero, + /// Treat them as if the user configured [`None`]. + TreatAsNone, +} + impl Role where @@ -704,8 +716,8 @@ mod tests { fn replica_counts_with_all_replicas_set() { let role = construct_role_with_replicas([Some(3), Some(2), Some(5)]); - assert_eq!(role.fixed_replica_count(false), Some(10)); - assert_eq!(role.fixed_replica_count(true), Some(10)); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(10)); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), Some(10)); assert_eq!(role.estimated_replica_count(), 10); } @@ -713,8 +725,8 @@ mod tests { fn replica_counts_with_one_replica_unset() { let role = construct_role_with_replicas([Some(3), None, Some(2)]); - assert_eq!(role.fixed_replica_count(false), None); - assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), None); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); assert_eq!(role.estimated_replica_count(), 6); } @@ -722,9 +734,9 @@ mod tests { fn replica_counts_with_a_zero_replica() { let role = construct_role_with_replicas([Some(3), Some(0)]); - assert_eq!(role.fixed_replica_count(false), Some(3)); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(3)); // With treat_zero_as_none the zero turns the whole count into None. - assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); assert_eq!(role.estimated_replica_count(), 3); } @@ -732,8 +744,8 @@ mod tests { fn replica_counts_with_a_single_zero_role_group() { let role = construct_role_with_replicas([Some(0)]); - assert_eq!(role.fixed_replica_count(false), Some(0)); - assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0)); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); assert_eq!(role.estimated_replica_count(), 0); } @@ -741,8 +753,8 @@ mod tests { fn replica_counts_without_role_groups() { let role = construct_role_with_replicas(vec![]); - assert_eq!(role.fixed_replica_count(false), Some(0)); - assert_eq!(role.fixed_replica_count(true), None); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0)); + assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); assert_eq!(role.estimated_replica_count(), 0); } From 91688087bf8237420d144fb0a038a1932387dc54 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 12:55:57 +0200 Subject: [PATCH 6/8] Random rustdoc fix --- crates/stackable-operator/src/builder/pdb.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/stackable-operator/src/builder/pdb.rs b/crates/stackable-operator/src/builder/pdb.rs index 2d1af56f2..5e2fb1d2c 100644 --- a/crates/stackable-operator/src/builder/pdb.rs +++ b/crates/stackable-operator/src/builder/pdb.rs @@ -154,7 +154,7 @@ impl PodDisruptionBudgetBuilder { /// Mutually exclusive with [`PodDisruptionBudgetBuilder::with_max_unavailable`]. #[deprecated( since = "0.51.0", - note = "It is strongly recommended to use [`max_unavailable`]. Please read the ADR on Pod disruptions before using this function." + note = "It is strongly recommended to use [`PodDisruptionBudgetBuilder::with_max_unavailable`]. Please read the ADR on Pod disruptions before using this function." )] pub fn with_min_available( self, From 37cdba2958c0e2990d14910d0a3306fa4cf6ec28 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Thu, 2 Jul 2026 13:22:25 +0200 Subject: [PATCH 7/8] cargo fmt --- crates/stackable-operator/src/role_utils.rs | 59 +++++++++++++++------ 1 file changed, 44 insertions(+), 15 deletions(-) diff --git a/crates/stackable-operator/src/role_utils.rs b/crates/stackable-operator/src/role_utils.rs index 63fc027ff..b0b1dcc8d 100644 --- a/crates/stackable-operator/src/role_utils.rs +++ b/crates/stackable-operator/src/role_utils.rs @@ -418,12 +418,11 @@ where /// The argument `zero_replicas_counting` is a safety mechanism, which allows the caller to /// decide if an explicit replica count of `0` should be treated as [`None`]. It also means that /// [`None`] is returned in case no roleGroups are configured at all. - pub fn fixed_replica_count( - &self, - zero_replicas_counting: ZeroReplicasCounting, - ) -> Option { + pub fn fixed_replica_count(&self, zero_replicas_counting: ZeroReplicasCounting) -> Option { // An empty role has no fixed replica count when zeros are treated as None. - if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone && self.role_groups.is_empty() { + if zero_replicas_counting == ZeroReplicasCounting::TreatAsNone + && self.role_groups.is_empty() + { return None; } @@ -716,8 +715,14 @@ mod tests { fn replica_counts_with_all_replicas_set() { let role = construct_role_with_replicas([Some(3), Some(2), Some(5)]); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(10)); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), Some(10)); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), + Some(10) + ); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), + Some(10) + ); assert_eq!(role.estimated_replica_count(), 10); } @@ -725,8 +730,14 @@ mod tests { fn replica_counts_with_one_replica_unset() { let role = construct_role_with_replicas([Some(3), None, Some(2)]); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), None); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), + None + ); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), + None + ); assert_eq!(role.estimated_replica_count(), 6); } @@ -734,9 +745,15 @@ mod tests { fn replica_counts_with_a_zero_replica() { let role = construct_role_with_replicas([Some(3), Some(0)]); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(3)); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), + Some(3) + ); // With treat_zero_as_none the zero turns the whole count into None. - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), + None + ); assert_eq!(role.estimated_replica_count(), 3); } @@ -744,8 +761,14 @@ mod tests { fn replica_counts_with_a_single_zero_role_group() { let role = construct_role_with_replicas([Some(0)]); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0)); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), + Some(0) + ); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), + None + ); assert_eq!(role.estimated_replica_count(), 0); } @@ -753,8 +776,14 @@ mod tests { fn replica_counts_without_role_groups() { let role = construct_role_with_replicas(vec![]); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), Some(0)); - assert_eq!(role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), None); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsZero), + Some(0) + ); + assert_eq!( + role.fixed_replica_count(ZeroReplicasCounting::TreatAsNone), + None + ); assert_eq!(role.estimated_replica_count(), 0); } From 7bed44c77c0b9232f126335d0373e2a8ac7c77f8 Mon Sep 17 00:00:00 2001 From: Sebastian Bernauer Date: Fri, 3 Jul 2026 11:40:27 +0200 Subject: [PATCH 8/8] Unrelated docs fix --- crates/stackable-operator/crds/AuthenticationClass.yaml | 2 +- crates/stackable-operator/crds/DummyCluster.yaml | 2 +- crates/stackable-operator/crds/S3Bucket.yaml | 2 +- crates/stackable-operator/crds/S3Connection.yaml | 2 +- crates/stackable-operator/src/commons/secret_class.rs | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/stackable-operator/crds/AuthenticationClass.yaml b/crates/stackable-operator/crds/AuthenticationClass.yaml index 438cb49ec..8b35e556c 100644 --- a/crates/stackable-operator/crds/AuthenticationClass.yaml +++ b/crates/stackable-operator/crds/AuthenticationClass.yaml @@ -104,7 +104,7 @@ spec: type: array type: object secretClass: - description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) containing the LDAP bind credentials.' + description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) providing the requested secrets.' type: string required: - secretClass diff --git a/crates/stackable-operator/crds/DummyCluster.yaml b/crates/stackable-operator/crds/DummyCluster.yaml index fab66510b..79692113e 100644 --- a/crates/stackable-operator/crds/DummyCluster.yaml +++ b/crates/stackable-operator/crds/DummyCluster.yaml @@ -1932,7 +1932,7 @@ spec: type: array type: object secretClass: - description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) containing the LDAP bind credentials.' + description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) providing the requested secrets.' type: string required: - secretClass diff --git a/crates/stackable-operator/crds/S3Bucket.yaml b/crates/stackable-operator/crds/S3Bucket.yaml index 650ed1025..f44b24004 100644 --- a/crates/stackable-operator/crds/S3Bucket.yaml +++ b/crates/stackable-operator/crds/S3Bucket.yaml @@ -93,7 +93,7 @@ spec: type: array type: object secretClass: - description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) containing the LDAP bind credentials.' + description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) providing the requested secrets.' type: string required: - secretClass diff --git a/crates/stackable-operator/crds/S3Connection.yaml b/crates/stackable-operator/crds/S3Connection.yaml index 29468bd8c..997108950 100644 --- a/crates/stackable-operator/crds/S3Connection.yaml +++ b/crates/stackable-operator/crds/S3Connection.yaml @@ -77,7 +77,7 @@ spec: type: array type: object secretClass: - description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) containing the LDAP bind credentials.' + description: '[SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) providing the requested secrets.' type: string required: - secretClass diff --git a/crates/stackable-operator/src/commons/secret_class.rs b/crates/stackable-operator/src/commons/secret_class.rs index c32bbac64..43dd69713 100644 --- a/crates/stackable-operator/src/commons/secret_class.rs +++ b/crates/stackable-operator/src/commons/secret_class.rs @@ -20,7 +20,7 @@ pub enum SecretClassVolumeError { )] #[serde(rename_all = "camelCase")] pub struct SecretClassVolume { - /// [SecretClass](DOCS_BASE_URL_PLACEHOLDER/secret-operator/secretclass) containing the LDAP bind credentials. + /// [SecretClass](DOCS_BASE_URL_PLACEHOLDER/secret-operator/secretclass) providing the requested secrets. pub secret_class: String, /// [Scope](DOCS_BASE_URL_PLACEHOLDER/secret-operator/scope) of the