feat(types): Add LimitsConfig field to ComponentProperties

crates/wadm-types/src/bindings.rs

@@ -113,6 +113,7 @@ impl From<ComponentProperties> for wadm::types::ComponentProperties {
             id: properties.id,
             config: properties.config.into_iter().map(|c| c.into()).collect(),
             secrets: properties.secrets.into_iter().map(|c| c.into()).collect(),
+            limits: properties.limits.into_iter().map(|c| c.into()).collect(),
         }
     }
 }
@@ -431,6 +432,7 @@ impl From<wadm::types::ComponentProperties> for ComponentProperties {
             id: properties.id,
             config: properties.config.into_iter().map(|c| c.into()).collect(),
             secrets: properties.secrets.into_iter().map(|c| c.into()).collect(),
+            limits: properties.limits.map(Into::into),
         }
     }
 }

crates/wadm-types/src/lib.rs

@@ -298,6 +298,9 @@ pub struct ComponentProperties {
     /// these values at runtime using `wasmcloud:secrets/store`.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub secrets: Vec<SecretProperty>,
+    /// This Config holds the component's metadata properties like memory limits and execution time limits
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limits: Option<LimitsConfig>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Default, ToSchema, JsonSchema)]
@@ -333,6 +336,20 @@ pub struct SecretSourceProperty {
     pub version: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, ToSchema, JsonSchema)]
+pub struct LimitProperties {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_linear_memory: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_execution_time: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, ToSchema, JsonSchema)]
+pub struct LimitsConfig {
+    pub name: String,
+    pub properties: LimitProperties,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, ToSchema, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct CapabilityProperties {
@@ -845,6 +862,7 @@ mod test {
                     id: None,
                     config: vec![],
                     secrets: vec![],
+                    limits: None,
                 },
             },
             traits: Some(trait_vec),

crates/wadm-types/wit/deps/wadm/types.wit

@@ -123,6 +123,17 @@ interface types {
         id: option<string>,
         config: list<config-property>,
         secrets: list<secret-property>,
+        limits: list<limits-config>,
+    }
+
+    record limits-config {
+        name: string,
+        properties: limit-properties,
+    }
+
+    record limit-properties {
+        max-linear-memory: option<string>,
+        max-execution-time: option<string>,
     }
 
     // Properties for a capability

crates/wadm/Cargo.toml

@@ -46,6 +46,8 @@ uuid = { workspace = true }
 wadm-types = { workspace = true }
 wasmcloud-control-interface = { workspace = true }
 wasmcloud-secrets-types = { workspace = true }
+humantime = "2.2.0"
+parse-size = "1.1.0"
 
 [dev-dependencies]
 serial_test = "3"

crates/wadm/src/commands/mod.rs

@@ -78,6 +78,7 @@ impl Command {
                 component_id,
                 host_id,
                 count,
+                limits,
                 reference,
                 annotations,
                 model_name,
@@ -94,6 +95,7 @@ impl Command {
                         annotations: annotations.to_owned(),
                         // We don't know this field from the command
                         claims: None,
+                        limits: limits.clone(),
                     }),
                     Some(Event::ComponentScaleFailed(ComponentScaleFailed {
                         component_id: component_id.to_owned(),
@@ -122,6 +124,8 @@ pub struct ScaleComponent {
     pub host_id: String,
     /// The number of components to scale to
     pub count: u32,
+    /// The limits for the component, if any
+    pub limits: Option<HashMap<String, String>>,
     /// The OCI or bindle reference to scale
     pub reference: String,
     /// The name of the model/manifest that generated this command

crates/wadm/src/events/types.rs

@@ -300,6 +300,7 @@ pub struct ComponentScaled {
     pub claims: Option<ComponentClaims>,
     pub image_ref: String,
     pub max_instances: usize,
+    pub limits: Option<HashMap<String, String>>,
     pub component_id: String,
     #[serde(default)]
     pub host_id: String,

crates/wadm/src/scaler/configscaler.rs

@@ -279,7 +279,8 @@ mod test {
                     image_ref: "foo".to_string(),
                     max_instances: 0,
                     component_id: "fooo".to_string(),
-                    host_id: "hostid".to_string()
+                    host_id: "hostid".to_string(),
+                    limits: None,
                 }))
                 .await
                 .expect("handle_event should succeed"),

crates/wadm/src/scaler/convert.rs

@@ -4,6 +4,7 @@
 use std::{collections::HashMap, time::Duration};
 
 use anyhow::Result;
+use parse_size::parse_size;
 use tracing::{error, warn};
 use wadm_types::{
     api::StatusInfo, CapabilityProperties, Component, ComponentProperties, ConfigProperty,
@@ -195,7 +196,14 @@ fn component_scalers<S, P, L>(
             &properties.secrets,
             policies,
         );
-
+        // write a function call here that converts the limits from componentProperties and unmarshalls them into the correct format
+        // It first checks if the limts are set in their correct foormat, ie humantime for max_execution_time and human readable memory 
+        // for max_memory_limits like "4gb" or so
+        // if successful, they are set in a hashmap with the keys "max_execution_time" and "max_memory_limits" and then passed to the scalers.
+        let limits = properties
+            .limits
+            .as_ref()
+            .and_then(|_| compute_limits(properties));
         config_names.append(&mut secret_names.clone());
         // TODO(#451): Consider a way to report on status of a shared component
         match (trt.trait_type.as_str(), &trt.properties, &properties.image) {
@@ -226,6 +234,7 @@ fn component_scalers<S, P, L>(
                         p.to_owned(),
                         component_name,
                         config_names,
+                        limits,
                     ),
                     notifier.clone(),
                     config_scalers,
@@ -246,6 +255,7 @@ fn component_scalers<S, P, L>(
                         p.to_owned(),
                         component_name,
                         config_names,
+                        limits,
                     ),
                     notifier.clone(),
                     config_scalers,
@@ -741,6 +751,78 @@ fn resolve_manifest_component<'a>(
     }
 }
 
+// add new function to compute the limits from componentProperties and unmarshall them into the correct format
+// It first checks if the limits are set in their correct format, ie humantime for max_execution_time and human readable memory
+/// Parse and validate memory size from human-readable format to bytes
+fn parse_and_validate_memory_size(input: &str) -> Result<usize, String> {
+    let bytes = parse_size(input).map_err(|e| format!("Parse error: {}", e))?;
+
+    if bytes > usize::MAX as u64 {
+        Err(format!(
+            "Size too large: max allowed is {} bytes (got {} bytes)",
+            usize::MAX,
+            bytes
+        ))
+    } else {
+        Ok(bytes as usize)
+    }
+}
+
+/// Parse execution time from humantime format to seconds
+fn parse_and_validate_execution_time(input: &str) -> Result<u64, String> {
+    humantime::parse_duration(input)
+        .map(|duration| duration.as_secs())
+        .map_err(|e| format!("Invalid time format: {}", e))
+}
+
+/// Computes limits for components from ComponentProperties
+/// Converts human-readable formats to numeric values for the control interface
+pub(crate) fn compute_limits(properties: &ComponentProperties) -> Option<HashMap<String, String>> {
+    let mut limits = HashMap::new();
+
+    if let Some(max_execution_time) = properties
+        .limits
+        .as_ref()
+        .and_then(|l| l.properties.max_execution_time.as_ref())
+    {
+        match parse_and_validate_execution_time(max_execution_time) {
+            Ok(seconds) => {
+                limits.insert("max_execution_time".to_string(), seconds.to_string());
+            }
+            Err(e) => {
+                warn!(
+                    "Invalid max_execution_time format '{}': {}",
+                    max_execution_time, e
+                );
+            }
+        }
+    }
+
+    if let Some(max_memory_limits) = &properties
+        .limits
+        .as_ref()
+        .and_then(|l| l.properties.max_linear_memory.as_ref())
+    {
+        match parse_and_validate_memory_size(max_memory_limits) {
+            Ok(bytes) => {
+                limits.insert("max_memory_limit".to_string(), bytes.to_string());
+            }
+            Err(e) => {
+                warn!(
+                    "Invalid max_memory_limits format '{}': {}",
+                    max_memory_limits, e
+                );
+            }
+        }
+    }
+
+    if limits.is_empty() {
+        None
+    } else {
+        Some(limits)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::compute_component_id;