refactor: move constants and use Port type

Author: maltesander

rust/operator-binary/src/controller/build.rs

@@ -2,8 +2,10 @@
 //!
 //! `properties` renders the Trino `.properties` files; `resource` builds the individual
 //! Kubernetes resources (ConfigMap, Service, Listener, PDB, …); `graceful_shutdown`
-//! contributes graceful-shutdown `config.properties` entries and Pod lifecycle configuration.
+//! contributes graceful-shutdown `config.properties` entries and Pod lifecycle configuration;
+//! `ports` derives the client-facing port from the validated TLS configuration.
 
 pub mod graceful_shutdown;
+pub mod ports;
 pub mod properties;
 pub mod resource;

rust/operator-binary/src/controller/build/graceful_shutdown.rs

@@ -125,9 +125,9 @@ pub fn add_graceful_shutdown_config(
                                 echo 'Successfully sent graceful shutdown command' >> /proc/1/fd/1 2>&1
                                 echo 'Sleeping {termination_grace_period_seconds} seconds' >> /proc/1/fd/1 2>&1
                                 sleep {termination_grace_period_seconds}",
-                                protocol = cluster.exposed_protocol(),
+                                protocol = super::ports::exposed_protocol(cluster),
                                 host = "127.0.0.1",
-                                port = cluster.exposed_port(),
+                                port = super::ports::exposed_port(cluster),
                             ),
                         ]),
                     }),

rust/operator-binary/src/controller/build/ports.rs

@@ -0,0 +1,27 @@
+//! The client-facing port Trino exposes, derived from the validated TLS configuration.
+//!
+//! Mapping the server-TLS flag onto a concrete port number / name is a resource-shaping decision,
+//! so it lives in the build step rather than on [`ValidatedCluster`].
+
+use crate::{
+    controller::ValidatedCluster,
+    crd::{HTTP_PORT, HTTP_PORT_NAME, HTTPS_PORT, HTTPS_PORT_NAME},
+};
+
+/// The client-facing port Trino exposes: HTTPS when server TLS is enabled, otherwise HTTP.
+pub(crate) fn exposed_port(cluster: &ValidatedCluster) -> u16 {
+    if cluster.server_tls_enabled() {
+        HTTPS_PORT
+    } else {
+        HTTP_PORT
+    }
+}
+
+/// The name of the client-facing port (see [`exposed_port`]).
+pub(crate) fn exposed_protocol(cluster: &ValidatedCluster) -> &'static str {
+    if cluster.server_tls_enabled() {
+        HTTPS_PORT_NAME
+    } else {
+        HTTP_PORT_NAME
+    }
+}

rust/operator-binary/src/controller/build/resource/listener.rs

@@ -6,7 +6,10 @@ use stackable_operator::{
     kvp::Labels,
 };
 
-use crate::{controller::ValidatedCluster, crd::TrinoRole};
+use crate::{
+    controller::{ValidatedCluster, build::ports},
+    crd::TrinoRole,
+};
 
 pub const LISTENER_VOLUME_NAME: &str = "listener";
 pub const LISTENER_VOLUME_DIR: &str = "/stackable/listener";
@@ -73,8 +76,8 @@ pub fn secret_volume_listener_scope(role: &TrinoRole) -> Option<String> {
 
 /// We only use the http/https port here and intentionally omit the metrics one.
 fn listener_ports(cluster: &ValidatedCluster) -> Vec<ListenerPort> {
-    let name = cluster.exposed_protocol().to_string();
-    let port = cluster.exposed_port().into();
+    let name = ports::exposed_protocol(cluster).to_string();
+    let port = ports::exposed_port(cluster).into();
 
     vec![ListenerPort {
         name,

rust/operator-binary/src/controller/build/resource/service.rs

@@ -6,7 +6,7 @@ use stackable_operator::{
 };
 
 use crate::{
-    controller::ValidatedCluster,
+    controller::{ValidatedCluster, build::ports},
     crd::{METRICS_PORT, METRICS_PORT_NAME, TrinoRole},
 };
 
@@ -77,8 +77,8 @@ pub fn build_rolegroup_metrics_service(
 }
 
 pub(crate) fn headless_service_ports(cluster: &ValidatedCluster) -> Vec<ServicePort> {
-    let name = cluster.exposed_protocol().to_string();
-    let port = cluster.exposed_port().into();
+    let name = ports::exposed_protocol(cluster).to_string();
+    let port = ports::exposed_port(cluster).into();
 
     vec![ServicePort {
         name: Some(name),

rust/operator-binary/src/controller/build/resource/statefulset.rs

@@ -582,7 +582,7 @@ fn http_get_probe(cluster: &ValidatedCluster) -> HTTPGetAction {
 ///
 /// This probe works on coordinators and workers.
 fn finished_starting_probe(cluster: &ValidatedCluster) -> ExecAction {
-    let port = cluster.exposed_port();
+    let port = build::ports::exposed_port(cluster);
     let schema = if cluster.server_tls_enabled() {
         "https"
     } else {

rust/operator-binary/src/controller/mod.rs

@@ -36,10 +36,7 @@ use crate::{
         client_protocol::ResolvedClientProtocolConfig,
         fault_tolerant_execution::ResolvedFaultTolerantExecutionConfig,
     },
-    crd::{
-        APP_NAME, HTTP_PORT, HTTP_PORT_NAME, HTTPS_PORT, HTTPS_PORT_NAME, TrinoRole,
-        discovery::TrinoPodRef, v1alpha1,
-    },
+    crd::{APP_NAME, TrinoRole, discovery::TrinoPodRef, v1alpha1},
     trino_controller::{CONTROLLER_NAME, OPERATOR_NAME},
 };
 
@@ -193,27 +190,6 @@ impl ValidatedCluster {
         self.cluster_config.authentication_enabled() || self.server_tls_enabled()
     }
 
-    /// The client-facing port Trino exposes: HTTPS when server TLS is enabled, otherwise HTTP.
-    ///
-    /// Replaces `v1alpha1::TrinoCluster::exposed_port`, derived here from the validated TLS config
-    /// so build steps don't re-read the raw cluster.
-    pub fn exposed_port(&self) -> u16 {
-        if self.server_tls_enabled() {
-            HTTPS_PORT
-        } else {
-            HTTP_PORT
-        }
-    }
-
-    /// The name of the client-facing port (see [`Self::exposed_port`]).
-    pub fn exposed_protocol(&self) -> &'static str {
-        if self.server_tls_enabled() {
-            HTTPS_PORT_NAME
-        } else {
-            HTTP_PORT_NAME
-        }
-    }
-
     /// Type-safe names for the resources of a given role group.
     pub(crate) fn resource_names(&self, role: &TrinoRole, role_group_name: &str) -> ResourceNames {
         ResourceNames {