Struct DeploymentContract 

pub struct DeploymentContract {

    pub schema_version: u32,
    pub app_name: String,
    pub binary_name: String,
    pub description: String,
    pub metrics_port: u16,
    pub health: HealthContract,
    pub env_prefix: String,
    pub metric_prefix: String,
    pub config_mount_path: String,
    pub image_registry: String,
    pub extra_ports: Vec<PortContract>,
    pub entrypoint_args: Vec<String>,
    pub secrets: Vec<SecretGroupContract>,
    pub default_config: Option<Value>,
    pub depends_on: Vec<String>,
    pub keda: Option<KedaContract>,
    pub base_image: String,
    pub native_deps: NativeDepsContract,
    pub image_profile: ImageProfile,
    pub oci_labels: OciLabels,
}

Available on crate feature deployment only.

Deployment-facing contract points derived from the app config cascade.

Apps build this from their Config::default(). Validation functions compare Helm charts and Dockerfiles against these values. Generation functions create deployment artifacts (Dockerfile, Helm chart, Compose fragment) from scratch.

Fields

schema_version: u32

Contract schema version. CI checks this and fails if unsupported.

app_name: String

Application name (e.g., “dfe-loader”) – matched against Chart.yaml name.

binary_name: String

Binary name (e.g., “dfe-loader”). Defaults to app_name if empty.

description: String

One-line description for Chart.yaml.

metrics_port: u16

Metrics/health listen port (e.g., 9090).

health: HealthContract

Health probe endpoint paths.

env_prefix: String

Environment variable prefix (e.g., “DFE_LOADER”). Used with __ nesting for figment config cascade.

metric_prefix: String

Prometheus metric namespace/prefix (e.g., “loader”).

config_mount_path: String

Config file mount path (e.g., “/etc/dfe/loader.yaml”).

image_registry: String

Container registry base (e.g., “ghcr.io/hyperi-io”).

extra_ports: Vec<PortContract>

Additional ports beyond metrics (e.g., HTTP data port for receiver).

entrypoint_args: Vec<String>

Default ENTRYPOINT args (e.g., ["--config", "/etc/dfe/loader.yaml"]).

secrets: Vec<SecretGroupContract>

Secret groups injected from K8s Secrets.

default_config: Option<Value>

App-specific config YAML for values.yaml (serialised as serde_json::Value).

depends_on: Vec<String>

Docker Compose service dependencies (e.g., ["kafka", "clickhouse"]).

keda: Option<KedaContract>

KEDA autoscaling contract (None if KEDA not used).

base_image: String

Base container image for the runtime stage.

native_deps: NativeDepsContract

Runtime native dependencies for the container image.

Use NativeDepsContract::for_rustlib_features to auto-populate from hyperi-rustlib feature flags. The Dockerfile generator emits the correct APT repo setup and package installation commands.

image_profile: ImageProfile

Image profile – production (minimal) or development (debug tools).

Defaults to ImageProfile::Production. Use with_dev_profile to derive a development variant from an existing contract.

oci_labels: OciLabels

OCI image labels (static – dynamic labels injected by CI at build time).

Implementations

impl DeploymentContract

pub fn binary(&self) -> &str

Get the effective binary name (falls back to app_name).

pub fn config_filename(&self) -> &str

Get the config file name from the mount path (e.g., “loader.yaml”).

pub fn config_dir(&self) -> &str

Get the config mount directory (e.g., “/etc/dfe”).

pub fn to_json(&self) -> String

Serialise the contract to JSON for --emit-contract CLI support.

pub fn to_yaml(&self) -> String

Serialise the contract to YAML.

pub fn with_dev_profile(&self) -> Self

Return a clone with ImageProfile::Development set.

Useful for generating both production and dev Dockerfiles from a single contract definition.

Trait Implementations

impl Clone for DeploymentContract

fn clone(&self) -> DeploymentContract

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeploymentContract

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeploymentContract

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DeploymentContract

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.