From 1315e2135486e1512737729a85d5d31e10222ef5 Mon Sep 17 00:00:00 2001 From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com> Date: Fri, 17 Jul 2026 09:42:21 +0200 Subject: [PATCH 1/5] feat: add crd::openlineage module --- crates/stackable-operator/CHANGELOG.md | 8 + .../crds/OpenLineageConnection.yaml | 91 ++++++++++ crates/stackable-operator/src/crd/mod.rs | 1 + .../src/crd/openlineage/mod.rs | 157 ++++++++++++++++++ .../src/crd/openlineage/v1alpha1_impl.rs | 62 +++++++ crates/xtask/src/crd/mod.rs | 2 + 6 files changed, 321 insertions(+) create mode 100644 crates/stackable-operator/crds/OpenLineageConnection.yaml create mode 100644 crates/stackable-operator/src/crd/openlineage/mod.rs create mode 100644 crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs diff --git a/crates/stackable-operator/CHANGELOG.md b/crates/stackable-operator/CHANGELOG.md index 8f50b4a44..387025091 100644 --- a/crates/stackable-operator/CHANGELOG.md +++ b/crates/stackable-operator/CHANGELOG.md @@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file. ## [Unreleased] +### Added + +- Add `crd::openlineage` module with the `OpenLineageConnection` CRD (a reusable connection to an + OpenLineage backend), an `InlineConnectionOrReference` wrapper with `resolve()`, and an embeddable + `OpenLineageJob` type for operators ([#XXXX]). + +[#XXXX]: https://github.com/stackabletech/operator-rs/pull/XXXX + ## [0.113.4] - 2026-07-09 ### Changed diff --git a/crates/stackable-operator/crds/OpenLineageConnection.yaml b/crates/stackable-operator/crds/OpenLineageConnection.yaml new file mode 100644 index 000000000..d7a9e5abd --- /dev/null +++ b/crates/stackable-operator/crds/OpenLineageConnection.yaml @@ -0,0 +1,91 @@ +--- +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + name: openlineageconnections.openlineage.stackable.tech +spec: + group: openlineage.stackable.tech + names: + categories: [] + kind: OpenLineageConnection + plural: openlineageconnections + shortNames: [] + singular: openlineageconnection + scope: Namespaced + versions: + - additionalPrinterColumns: [] + name: v1alpha1 + schema: + openAPIV3Schema: + description: A reusable definition of a connection to an OpenLineage backend. + properties: + spec: + description: |- + OpenLineage connection definition as a resource. + Learn more about [OpenLineage](https://openlineage.io/). + properties: + host: + description: 'Host of the OpenLineage backend without any protocol or port. For example: `marquez`.' + type: string + port: + description: 'Port the OpenLineage backend listens on. For example: `5000`.' + format: uint16 + maximum: 65535.0 + minimum: 0.0 + type: integer + tls: + description: Use a TLS connection. If not specified no TLS will be used. + nullable: true + properties: + verification: + description: The verification method used to verify the certificates of the server and/or the client. + oneOf: + - required: + - none + - required: + - server + properties: + none: + description: Use TLS but don't verify certificates. + type: object + server: + description: Use TLS and a CA certificate to verify the server. + properties: + caCert: + description: CA cert to verify the server. + oneOf: + - required: + - webPki + - required: + - secretClass + properties: + secretClass: + description: |- + Name of the [SecretClass](https://docs.stackable.tech/home/nightly/secret-operator/secretclass) which will provide the CA certificate. + Note that a SecretClass does not need to have a key but can also work with just a CA certificate, + so if you got provided with a CA cert but don't have access to the key you can still use this method. + type: string + webPki: + description: |- + Use TLS and the CA certificates trusted by the common web browsers to verify the server. + This can be useful when you e.g. use public AWS S3 or other public available services. + type: object + type: object + required: + - caCert + type: object + type: object + required: + - verification + type: object + required: + - host + - port + type: object + required: + - spec + title: OpenLineageConnection + type: object + served: true + storage: true + subresources: {} diff --git a/crates/stackable-operator/src/crd/mod.rs b/crates/stackable-operator/src/crd/mod.rs index be7ddad02..d80d75c34 100644 --- a/crates/stackable-operator/src/crd/mod.rs +++ b/crates/stackable-operator/src/crd/mod.rs @@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize}; pub mod authentication; pub mod git_sync; pub mod listener; +pub mod openlineage; pub mod s3; pub mod scaler; diff --git a/crates/stackable-operator/src/crd/openlineage/mod.rs b/crates/stackable-operator/src/crd/openlineage/mod.rs new file mode 100644 index 000000000..bcd589452 --- /dev/null +++ b/crates/stackable-operator/src/crd/openlineage/mod.rs @@ -0,0 +1,157 @@ +use kube::CustomResource; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +use crate::{commons::tls_verification::TlsClientDetails, versioned::versioned}; + +mod v1alpha1_impl; + +// FIXME (@Techassi): This should be versioned as well, but the macro cannot +// handle new-type structs yet. +/// Use this type in your operator! +pub type ResolvedOpenLineageConnection = v1alpha1::OpenLineageConnectionSpec; + +#[versioned( + version(name = "v1alpha1"), + crates( + kube_core = "kube::core", + k8s_openapi = "k8s_openapi", + schemars = "schemars", + ) +)] +pub mod versioned { + pub mod v1alpha1 { + pub use v1alpha1_impl::OpenLineageError; + } + + /// OpenLineage connection definition as a resource. + /// Learn more about [OpenLineage](https://openlineage.io/). + #[versioned(crd( + group = "openlineage.stackable.tech", + kind = "OpenLineageConnection", + plural = "openlineageconnections", + doc = "A reusable definition of a connection to an OpenLineage backend.", + namespaced + ))] + #[derive(CustomResource, Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)] + #[serde(rename_all = "camelCase")] + pub struct OpenLineageConnectionSpec { + /// Host of the OpenLineage backend without any protocol or port. For example: `marquez`. + pub host: String, + + /// Port the OpenLineage backend listens on. For example: `5000`. + pub port: u16, + + /// Use a TLS connection. If not specified no TLS will be used. + /// When TLS server verification is configured, the transport uses `https` instead of `http`. + #[serde(flatten)] + pub tls: TlsClientDetails, + } + + /// An OpenLineage connection, either inlined or referenced by the name of an + /// [`OpenLineageConnection`] resource in the same namespace. + #[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)] + #[serde(rename_all = "camelCase")] + // TODO: This probably should be serde(untagged), but this would be a breaking change + pub enum InlineConnectionOrReference { + Inline(OpenLineageConnectionSpec), + Reference(String), + } + + /// OpenLineage lineage-emission configuration for a single workload/application. + /// + /// Embed this in an operator's workload spec to enable OpenLineage for that workload. + #[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)] + #[serde(rename_all = "camelCase")] + pub struct OpenLineageJob { + /// The OpenLineage backend connection, either inlined or referencing an + /// `OpenLineageConnection` resource by name. + pub connection: InlineConnectionOrReference, + + /// The OpenLineage namespace lineage is reported under. + /// If unset, operators typically default to the workload's Kubernetes namespace. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub namespace: Option, + + /// A stable OpenLineage job/application name. Setting this prevents fragmented run history. + /// If unset, operators resolve a name from workload-specific configuration. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub app_name: Option, + } +} + +#[cfg(test)] +impl stackable_versioned::test_utils::RoundtripTestData for v1alpha1::OpenLineageConnectionSpec { + fn roundtrip_test_data() -> Vec { + crate::utils::yaml_from_str_singleton_map(indoc::indoc! {" + - host: marquez + port: 5000 + - host: marquez + port: 5000 + tls: + verification: + none: {} + - host: marquez + port: 5000 + tls: + verification: + server: + caCert: + secretClass: openlineage-cert + "}) + .expect("Failed to parse OpenLineageConnectionSpec YAML") + } +} + +#[cfg(test)] +mod tests { + use crate::{ + commons::tls_verification::{ + CaCert, Tls, TlsClientDetails, TlsServerVerification, TlsVerification, + }, + crd::openlineage::v1alpha1::OpenLineageConnectionSpec, + }; + + #[test] + fn http_transport_url_without_tls() { + let connection = OpenLineageConnectionSpec { + host: "marquez".to_string(), + port: 5000, + tls: TlsClientDetails { tls: None }, + }; + + assert_eq!(connection.transport_url(), "http://marquez:5000"); + } + + #[test] + fn https_transport_url_with_server_verification() { + let connection = OpenLineageConnectionSpec { + host: "marquez".to_string(), + port: 5000, + tls: TlsClientDetails { + tls: Some(Tls { + verification: TlsVerification::Server(TlsServerVerification { + ca_cert: CaCert::WebPki {}, + }), + }), + }, + }; + + assert_eq!(connection.transport_url(), "https://marquez:5000"); + } + + #[test] + fn http_transport_url_without_verification() { + let connection = OpenLineageConnectionSpec { + host: "marquez".to_string(), + port: 5000, + tls: TlsClientDetails { + tls: Some(Tls { + verification: TlsVerification::None {}, + }), + }, + }; + + assert_eq!(connection.transport_url(), "http://marquez:5000"); + } +} diff --git a/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs new file mode 100644 index 000000000..f76173085 --- /dev/null +++ b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs @@ -0,0 +1,62 @@ +use snafu::{ResultExt as _, Snafu}; + +use crate::{ + client::Client, + crd::openlineage::{ + ResolvedOpenLineageConnection, + v1alpha1::{InlineConnectionOrReference, OpenLineageConnection, OpenLineageConnectionSpec}, + }, +}; + +#[derive(Debug, Snafu)] +pub enum OpenLineageError { + #[snafu(display("failed to retrieve OpenLineage connection '{open_lineage_connection}'"))] + RetrieveOpenLineageConnection { + #[snafu(source(from(crate::client::Error, Box::new)))] + source: Box, + open_lineage_connection: String, + }, +} + +impl OpenLineageConnectionSpec { + /// Build the OpenLineage transport URL from this connection. + /// + /// The scheme is `https` when TLS server verification is configured + /// (`tls.verification.server`), otherwise `http`. + pub fn transport_url(&self) -> String { + let scheme = if self.tls.uses_tls_verification() { + "https" + } else { + "http" + }; + + format!( + "{scheme}://{host}:{port}", + host = self.host, + port = self.port + ) + } +} + +impl InlineConnectionOrReference { + pub async fn resolve( + self, + client: &Client, + namespace: &str, + ) -> Result { + match self { + Self::Inline(inline) => Ok(inline), + Self::Reference(reference) => { + let connection_spec = client + .get::(&reference, namespace) + .await + .context(RetrieveOpenLineageConnectionSnafu { + open_lineage_connection: reference, + })? + .spec; + + Ok(connection_spec) + } + } + } +} diff --git a/crates/xtask/src/crd/mod.rs b/crates/xtask/src/crd/mod.rs index f3ed2caa0..7cb127306 100644 --- a/crates/xtask/src/crd/mod.rs +++ b/crates/xtask/src/crd/mod.rs @@ -9,6 +9,7 @@ use stackable_operator::{ Listener, ListenerClass, ListenerClassVersion, ListenerVersion, PodListeners, PodListenersVersion, }, + openlineage::{OpenLineageConnection, OpenLineageConnectionVersion}, s3::{S3Bucket, S3BucketVersion, S3Connection, S3ConnectionVersion}, scaler::{Scaler, ScalerVersion}, }, @@ -75,6 +76,7 @@ pub fn generate_preview() -> Result<(), Error> { write_crd!(path, AuthenticationClass, V1Alpha1); write_crd!(path, Listener, V1Alpha1); write_crd!(path, ListenerClass, V1Alpha1); + write_crd!(path, OpenLineageConnection, V1Alpha1); write_crd!(path, PodListeners, V1Alpha1); write_crd!(path, S3Bucket, V1Alpha1); write_crd!(path, S3Connection, V1Alpha1); From bdfb9367dc0d125358a76df05bdb02c05c404290 Mon Sep 17 00:00:00 2001 From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com> Date: Fri, 17 Jul 2026 09:47:41 +0200 Subject: [PATCH 2/5] attempt to fix cargo deny lint by updating "spin" version --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c6c504fd2..56e176500 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3632,9 +3632,9 @@ dependencies = [ [[package]] name = "spin" -version = "0.9.8" +version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e" [[package]] name = "spki" From 8b1b821d6913d31a589cf7db5d089d982b220fb1 Mon Sep 17 00:00:00 2001 From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com> Date: Mon, 20 Jul 2026 10:35:52 +0200 Subject: [PATCH 3/5] add optional authentication class reference --- .../crds/OpenLineageConnection.yaml | 9 +++++ .../src/crd/openlineage/mod.rs | 14 +++++++ .../src/crd/openlineage/v1alpha1_impl.rs | 39 +++++++++++++++++-- 3 files changed, 59 insertions(+), 3 deletions(-) diff --git a/crates/stackable-operator/crds/OpenLineageConnection.yaml b/crates/stackable-operator/crds/OpenLineageConnection.yaml index d7a9e5abd..375a06f60 100644 --- a/crates/stackable-operator/crds/OpenLineageConnection.yaml +++ b/crates/stackable-operator/crds/OpenLineageConnection.yaml @@ -24,6 +24,15 @@ spec: OpenLineage connection definition as a resource. Learn more about [OpenLineage](https://openlineage.io/). properties: + authenticationClassRef: + description: |- + Name of an [`AuthenticationClass`](https://docs.stackable.tech/home/nightly/concepts/authentication) used + to authenticate against the OpenLineage backend. The `AuthenticationClass` is cluster-scoped + and referenced by name; it is resolved at runtime via + [`OpenLineageConnectionSpec::resolve_authentication_class`]. If not specified, no + authentication is used. + nullable: true + type: string host: description: 'Host of the OpenLineage backend without any protocol or port. For example: `marquez`.' type: string diff --git a/crates/stackable-operator/src/crd/openlineage/mod.rs b/crates/stackable-operator/src/crd/openlineage/mod.rs index bcd589452..9f7f39666 100644 --- a/crates/stackable-operator/src/crd/openlineage/mod.rs +++ b/crates/stackable-operator/src/crd/openlineage/mod.rs @@ -46,6 +46,14 @@ pub mod versioned { /// When TLS server verification is configured, the transport uses `https` instead of `http`. #[serde(flatten)] pub tls: TlsClientDetails, + + /// Name of an [`AuthenticationClass`](DOCS_BASE_URL_PLACEHOLDER/concepts/authentication) used + /// to authenticate against the OpenLineage backend. The `AuthenticationClass` is cluster-scoped + /// and referenced by name; it is resolved at runtime via + /// [`OpenLineageConnectionSpec::resolve_authentication_class`]. If not specified, no + /// authentication is used. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub authentication_class_ref: Option, } /// An OpenLineage connection, either inlined or referenced by the name of an @@ -98,6 +106,9 @@ impl stackable_versioned::test_utils::RoundtripTestData for v1alpha1::OpenLineag server: caCert: secretClass: openlineage-cert + - host: marquez + port: 5000 + authenticationClassRef: openlineage-auth "}) .expect("Failed to parse OpenLineageConnectionSpec YAML") } @@ -118,6 +129,7 @@ mod tests { host: "marquez".to_string(), port: 5000, tls: TlsClientDetails { tls: None }, + authentication_class_ref: None, }; assert_eq!(connection.transport_url(), "http://marquez:5000"); @@ -135,6 +147,7 @@ mod tests { }), }), }, + authentication_class_ref: None, }; assert_eq!(connection.transport_url(), "https://marquez:5000"); @@ -150,6 +163,7 @@ mod tests { verification: TlsVerification::None {}, }), }, + authentication_class_ref: None, }; assert_eq!(connection.transport_url(), "http://marquez:5000"); diff --git a/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs index f76173085..7a42af009 100644 --- a/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs +++ b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs @@ -2,9 +2,14 @@ use snafu::{ResultExt as _, Snafu}; use crate::{ client::Client, - crd::openlineage::{ - ResolvedOpenLineageConnection, - v1alpha1::{InlineConnectionOrReference, OpenLineageConnection, OpenLineageConnectionSpec}, + crd::{ + authentication::core::v1alpha1::AuthenticationClass, + openlineage::{ + ResolvedOpenLineageConnection, + v1alpha1::{ + InlineConnectionOrReference, OpenLineageConnection, OpenLineageConnectionSpec, + }, + }, }, }; @@ -16,6 +21,13 @@ pub enum OpenLineageError { source: Box, open_lineage_connection: String, }, + + #[snafu(display("failed to retrieve AuthenticationClass '{authentication_class}'"))] + RetrieveAuthenticationClass { + #[snafu(source(from(crate::client::Error, Box::new)))] + source: Box, + authentication_class: String, + }, } impl OpenLineageConnectionSpec { @@ -36,6 +48,27 @@ impl OpenLineageConnectionSpec { port = self.port ) } + + /// Resolves the [`AuthenticationClass`] referenced by this connection, if any. + /// + /// Returns `Ok(None)` when no `authenticationClassRef` is configured. The `AuthenticationClass` + /// is cluster-scoped, so no namespace is required. + pub async fn resolve_authentication_class( + &self, + client: &Client, + ) -> Result, OpenLineageError> { + let Some(authentication_class_ref) = &self.authentication_class_ref else { + return Ok(None); + }; + + let resolved = AuthenticationClass::resolve(client, authentication_class_ref) + .await + .context(RetrieveAuthenticationClassSnafu { + authentication_class: authentication_class_ref.clone(), + })?; + + Ok(Some(resolved)) + } } impl InlineConnectionOrReference { From 01535bc1acb05e8a28f098d40bf5bef3105e075e Mon Sep 17 00:00:00 2001 From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com> Date: Tue, 21 Jul 2026 15:16:31 +0200 Subject: [PATCH 4/5] refactor(openlineage): replace authenticationClassRef with credentialsSecretName AuthenticationClass is a server-side identity abstraction and does not fit outbound OpenLineage client->backend authentication, which is a static bearer token. Replace `authentication_class_ref` on OpenLineageConnectionSpec with an optional `credentials_secret_name` (a Secret holding the api key under `apiKey`) and drop `resolve_authentication_class`. See https://github.com/stackabletech/decisions/issues/90 Co-Authored-By: Claude Opus 4.8 (1M context) --- .../crds/OpenLineageConnection.yaml | 9 ++--- .../src/crd/openlineage/mod.rs | 17 ++++---- .../src/crd/openlineage/v1alpha1_impl.rs | 39 ++----------------- 3 files changed, 15 insertions(+), 50 deletions(-) diff --git a/crates/stackable-operator/crds/OpenLineageConnection.yaml b/crates/stackable-operator/crds/OpenLineageConnection.yaml index 375a06f60..14439f431 100644 --- a/crates/stackable-operator/crds/OpenLineageConnection.yaml +++ b/crates/stackable-operator/crds/OpenLineageConnection.yaml @@ -24,12 +24,11 @@ spec: OpenLineage connection definition as a resource. Learn more about [OpenLineage](https://openlineage.io/). properties: - authenticationClassRef: + credentialsSecretName: description: |- - Name of an [`AuthenticationClass`](https://docs.stackable.tech/home/nightly/concepts/authentication) used - to authenticate against the OpenLineage backend. The `AuthenticationClass` is cluster-scoped - and referenced by name; it is resolved at runtime via - [`OpenLineageConnectionSpec::resolve_authentication_class`]. If not specified, no + Name of a Secret containing the API key used to authenticate against the OpenLineage + backend. The API key must be stored under the key `apiKey`. The Secret must be located in + the same namespace as the workload using this connection. If not specified, no authentication is used. nullable: true type: string diff --git a/crates/stackable-operator/src/crd/openlineage/mod.rs b/crates/stackable-operator/src/crd/openlineage/mod.rs index 9f7f39666..1dfb5442e 100644 --- a/crates/stackable-operator/src/crd/openlineage/mod.rs +++ b/crates/stackable-operator/src/crd/openlineage/mod.rs @@ -47,13 +47,12 @@ pub mod versioned { #[serde(flatten)] pub tls: TlsClientDetails, - /// Name of an [`AuthenticationClass`](DOCS_BASE_URL_PLACEHOLDER/concepts/authentication) used - /// to authenticate against the OpenLineage backend. The `AuthenticationClass` is cluster-scoped - /// and referenced by name; it is resolved at runtime via - /// [`OpenLineageConnectionSpec::resolve_authentication_class`]. If not specified, no + /// Name of a Secret containing the API key used to authenticate against the OpenLineage + /// backend. The API key must be stored under the key `apiKey`. The Secret must be located in + /// the same namespace as the workload using this connection. If not specified, no /// authentication is used. #[serde(default, skip_serializing_if = "Option::is_none")] - pub authentication_class_ref: Option, + pub credentials_secret_name: Option, } /// An OpenLineage connection, either inlined or referenced by the name of an @@ -108,7 +107,7 @@ impl stackable_versioned::test_utils::RoundtripTestData for v1alpha1::OpenLineag secretClass: openlineage-cert - host: marquez port: 5000 - authenticationClassRef: openlineage-auth + credentialsSecretName: openlineage-credentials "}) .expect("Failed to parse OpenLineageConnectionSpec YAML") } @@ -129,7 +128,7 @@ mod tests { host: "marquez".to_string(), port: 5000, tls: TlsClientDetails { tls: None }, - authentication_class_ref: None, + credentials_secret_name: None, }; assert_eq!(connection.transport_url(), "http://marquez:5000"); @@ -147,7 +146,7 @@ mod tests { }), }), }, - authentication_class_ref: None, + credentials_secret_name: None, }; assert_eq!(connection.transport_url(), "https://marquez:5000"); @@ -163,7 +162,7 @@ mod tests { verification: TlsVerification::None {}, }), }, - authentication_class_ref: None, + credentials_secret_name: None, }; assert_eq!(connection.transport_url(), "http://marquez:5000"); diff --git a/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs index 7a42af009..f76173085 100644 --- a/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs +++ b/crates/stackable-operator/src/crd/openlineage/v1alpha1_impl.rs @@ -2,14 +2,9 @@ use snafu::{ResultExt as _, Snafu}; use crate::{ client::Client, - crd::{ - authentication::core::v1alpha1::AuthenticationClass, - openlineage::{ - ResolvedOpenLineageConnection, - v1alpha1::{ - InlineConnectionOrReference, OpenLineageConnection, OpenLineageConnectionSpec, - }, - }, + crd::openlineage::{ + ResolvedOpenLineageConnection, + v1alpha1::{InlineConnectionOrReference, OpenLineageConnection, OpenLineageConnectionSpec}, }, }; @@ -21,13 +16,6 @@ pub enum OpenLineageError { source: Box, open_lineage_connection: String, }, - - #[snafu(display("failed to retrieve AuthenticationClass '{authentication_class}'"))] - RetrieveAuthenticationClass { - #[snafu(source(from(crate::client::Error, Box::new)))] - source: Box, - authentication_class: String, - }, } impl OpenLineageConnectionSpec { @@ -48,27 +36,6 @@ impl OpenLineageConnectionSpec { port = self.port ) } - - /// Resolves the [`AuthenticationClass`] referenced by this connection, if any. - /// - /// Returns `Ok(None)` when no `authenticationClassRef` is configured. The `AuthenticationClass` - /// is cluster-scoped, so no namespace is required. - pub async fn resolve_authentication_class( - &self, - client: &Client, - ) -> Result, OpenLineageError> { - let Some(authentication_class_ref) = &self.authentication_class_ref else { - return Ok(None); - }; - - let resolved = AuthenticationClass::resolve(client, authentication_class_ref) - .await - .context(RetrieveAuthenticationClassSnafu { - authentication_class: authentication_class_ref.clone(), - })?; - - Ok(Some(resolved)) - } } impl InlineConnectionOrReference { From b209765b96869a9948b8ce154bed48dc3eed6491 Mon Sep 17 00:00:00 2001 From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com> Date: Tue, 21 Jul 2026 16:43:56 +0200 Subject: [PATCH 5/5] update changelog with pr number --- 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 387025091..eee4c6179 100644 --- a/crates/stackable-operator/CHANGELOG.md +++ b/crates/stackable-operator/CHANGELOG.md @@ -8,9 +8,9 @@ All notable changes to this project will be documented in this file. - Add `crd::openlineage` module with the `OpenLineageConnection` CRD (a reusable connection to an OpenLineage backend), an `InlineConnectionOrReference` wrapper with `resolve()`, and an embeddable - `OpenLineageJob` type for operators ([#XXXX]). + `OpenLineageJob` type for operators ([#1250]). -[#XXXX]: https://github.com/stackabletech/operator-rs/pull/XXXX +[#1250]: https://github.com/stackabletech/operator-rs/pull/XXXX ## [0.113.4] - 2026-07-09