Struct ConversionWebhookServer

pub struct ConversionWebhookServer { /* private fields */ }

A ready-to-use CRD conversion webhook server.

See ConversionWebhookServer::new() for usage examples.

Implementations

impl ConversionWebhookServer

pub async fn new<H>( crds_and_handlers: impl IntoIterator<Item = (CustomResourceDefinition, H)>, options: ConversionWebhookOptions, client: Client, ) -> Result<Self, ConversionWebhookError>

where H: WebhookHandler<ConversionReview, ConversionReview> + Clone + Send + Sync + 'static,

Creates a new conversion webhook server, which expects POST requests being made to the /convert/{crd name} endpoint.

You need to provide a few things for every CRD passed in via the crds_and_handlers argument:

1. The CRD
2. A conversion function to convert between CRD versions. Typically you would use the the auto-generated try_convert function on CRD spec definition structs for this.
3. A [kube::Client] used to create/update the CRDs.

The ConversionWebhookServer takes care of reconciling the CRDs into the Kubernetes cluster and takes care of adding itself as conversion webhook. This includes TLS certificates and CA bundles.

Example

use clap::Parser;
use stackable_webhook::{
    servers::{ConversionWebhookServer, ConversionWebhookOptions},
    constants::CONVERSION_WEBHOOK_HTTPS_PORT,
    WebhookOptions
};
use stackable_operator::{
    kube::Client,
    crd::s3::{S3Connection, S3ConnectionVersion},
    cli::ProductOperatorRun,
};

// Things that should already be in you operator:
const OPERATOR_NAME: &str = "product-operator";
let client = Client::try_default().await.expect("failed to create Kubernetes client");
let ProductOperatorRun {
    operator_environment,
    disable_crd_maintenance,
    ..
} = ProductOperatorRun::parse();

 let crds_and_handlers = [
    (
        S3Connection::merged_crd(S3ConnectionVersion::V1Alpha1)
            .expect("failed to merge S3Connection CRD"),
        S3Connection::try_convert as fn(_) -> _,
    ),
];

let options = ConversionWebhookOptions {
    socket_addr: format!("0.0.0.0:{CONVERSION_WEBHOOK_HTTPS_PORT}")
        .parse()
        .expect("static address is always valid"),
    namespace: operator_environment.operator_namespace,
    service_name: operator_environment.operator_service_name,
    maintain_crds: !disable_crd_maintenance,
    field_manager: OPERATOR_NAME.to_owned(),
};

// Construct the conversion webhook server
let conversion_webhook = ConversionWebhookServer::new(
    crds_and_handlers,
    options,
    client,
)
.await
.expect("failed to create ConversionWebhookServer");

conversion_webhook.run().await.expect("failed to run ConversionWebhookServer");

pub async fn run(self) -> Result<(), ConversionWebhookError>