fix: stuff

Author: NotAwar

.github/workflows/setup_test_env.yml

@@ -1,11 +1,35 @@
-# Experimental repo, will be updated - ignore all documentation and readme for now
+# Flipper Zero Kubernetes-inspired Containerization (Experimental)
 
-# Flipper Zero Firmware
+> **NOTICE:** This is an experimental fork exploring containerization concepts for Flipper Zero.
+> This is NOT the official Flipper Zero firmware repository.
 
-- [Flipper Zero Official Website](https://flipperzero.one). A simple way to explain to your friends what Flipper Zero can do.
-- [Flipper Zero Firmware Update](https://flipperzero.one/update). Improvements for your dolphin: latest firmware releases, upgrade tools for PC and mobile devices.
-- [User Documentation](https://docs.flipper.net). Learn more about your dolphin: specs, usage guides, and anything you want to ask.
-- [Developer Documentation](https://developer.flipper.net/flipperzero/doxygen). Dive into the Flipper Zero Firmware source code: build system, firmware structure, and more.
+This project implements a lightweight containerization system for Flipper Zero, inspired by Kubernetes
+but designed specifically for highly constrained microcontroller environments.
+
+## Key Features
+
+- **Container Runtime**: Lightweight container lifecycle management
+- **Pod Manifests**: Declarative application deployment
+- **Service Registry**: Efficient service discovery
+- **Resource Limits**: Memory and CPU quota enforcement
+
+## Hardware Constraints
+
+This implementation takes into account Flipper Zero's limited resources:
+- ~256KB RAM
+- ARM Cortex-M4 @ 64MHz
+- Limited flash storage
+- Battery-powered operation
+
+## Getting Started
+
+See the [Containerization Documentation](/documentation/Containerization.md) for details
+on how to use this system.
+
+## Original Project
+
+This is based on the [official Flipper Zero firmware](https://github.com/flipperdevices/flipperzero-firmware).
+Please refer to the official repository for the latest stable firmware.
 
 # Contributing
 

ReadMe.md

@@ -21,6 +21,21 @@ The containerization system implements several critical optimizations for resour
 - **Hash-Based Service Lookups**: O(1) service discovery with hash-based optimization
 - **Lazy Loading**: Resources are loaded only when needed to minimize memory footprint
 - **Zero-Copy IPC**: Communication between containers uses shared memory references when possible
+- **Static Pre-allocation**: Critical resources are pre-allocated to avoid heap fragmentation
+- **Scheduled Health Checks**: Health checks are performed at timed intervals, not continuously
+
+## Resource Constraints
+
+Flipper Zero has extremely limited resources compared to typical container environments:
+
+| Resource | Limit | Notes |
+|----------|-------|-------|
+| RAM | ~256KB | Shared between system and all containers |
+| CPU | 64MHz | ARM Cortex-M4 |
+| Storage | ~2MB | Available for all container images |
+| Power | Battery | Energy efficiency is critical |
+
+Containers must be designed with these constraints in mind. Typical containers use 2-10KB of RAM.
 
 ## Usage Examples
 
@@ -56,16 +71,21 @@ if(service) {
 
 ## Best Practices
 
-1. Always specify resource limits in pod manifests
-2. Keep container count low - optimal performance with 3-5 containers
-3. Use service registry for interface discovery rather than direct references
-4. Implement graceful shutdown in containers to prevent resource leaks
-5. Prefer static allocation over dynamic when possible
+1. **Resource Planning**: Always specify reasonable resource limits in pod manifests
+2. **Container Count**: Keep container count very low - optimal performance with 2-3 containers
+3. **Service Discovery**: Use service registry for interface discovery rather than direct references
+4. **Static Allocation**: Prefer static allocation over dynamic whenever possible
+5. **Lazy Initialization**: Initialize resources only when needed, not at startup
+6. **Garbage Collection**: Implement proper cleanup to prevent memory leaks
+7. **Health Checks**: Use periodic health checks with reasonable intervals (5-10s)
+8. **Namespaces**: Organize services into namespaces for better isolation
+9. **Minimal Containers**: Keep container images as small as possible
 
 ## Future Improvements
 
+- Resource quotas at namespace level
 - Container networking with virtual interfaces
 - Volume mounts for shared persistent storage
-- Container health checks and self-healing
+- Improved health checks and self-healing mechanisms
 - Configuration maps for environment variables
 

documentation/Containerization.md

@@ -13,12 +13,14 @@
 #define TAG "ContainerRT"
 
 // Reduced maximum number of containers to conserve memory
-#define MAX_CONTAINERS 8
+#define MAX_CONTAINERS 5  // Reduced from 8 to save memory
+#define CONTAINER_POOL_SIZE 3  // Pre-allocated container handles
 
 typedef struct Container {
     ContainerConfig config;
     ContainerStatus status;
     void* app_handle;
+    uint32_t last_health_check; // Timestamps to avoid checking too frequently
 } Container;
 
 struct ContainerRuntime {
@@ -29,10 +31,19 @@ struct ContainerRuntime {
     uint8_t active_container_count; // Track running containers separately
     bool running;
     ContainerHandle* recycled_container_pool; // Memory pool for container handles
+    ContainerHandle container_handle_pool[CONTAINER_POOL_SIZE]; // Static allocation
+    uint8_t next_free_handle_index;
 };
 
-// Ultra-minimal container health checker - just checks if the underlying app is still running
+// Memory-efficient container health checker - check less frequently
 static void container_check_health(Container* container) {
+    // Only check every 5 seconds to reduce CPU usage
+    uint32_t current_time = furi_get_tick();
+    if(current_time - container->last_health_check < 5000) {
+        return;
+    }
+    container->last_health_check = current_time;
+    
     if(!container || container->status.state != ContainerStateRunning) {
         return;
     }
@@ -198,6 +209,25 @@ static Container* container_find_free_slot(ContainerRuntime* runtime) {
     return NULL;
 }
 
+// Preflight check for resources - fail early if not enough memory
+bool container_runtime_can_start_container(ContainerRuntime* runtime, const ContainerConfig* config) {
+    // Calculate system's free memory - simplified example
+    size_t free_mem = furi_get_free_heap_size();
+    size_t required_mem = config->resource_limits.max_memory;
+    
+    // Add 20% overhead for container management
+    required_mem = required_mem * 1.2;
+    
+    // Check if there's enough memory
+    if(free_mem < required_mem) {
+        FURI_LOG_W(TAG, "Not enough memory to start container %s", config->name);
+        FURI_LOG_W(TAG, "Required: %d, Available: %d", required_mem, free_mem);
+        return false;
+    }
+    
+    return true;
+}
+
 Container* container_create(ContainerRuntime* runtime, const ContainerConfig* config) {
     furi_assert(runtime);
     furi_assert(config);
@@ -224,6 +254,12 @@ Container* container_create(ContainerRuntime* runtime, const ContainerConfig* co
         return NULL;
     }
 
+    // Check available resources before proceeding
+    if(!container_runtime_can_start_container(runtime, config)) {
+        furi_mutex_release(runtime->mutex);
+        return NULL;
+    }
+    
     // Find unused container slot
     Container* container = container_find_free_slot(runtime);
     if(!container) {
@@ -392,7 +428,7 @@ uint16_t container_runtime_get_running_count(ContainerRuntime* runtime) {
     return count;
 }
 
-// Memory optimization - reuse container objects where possible
+// Optimize memory allocation with static pool
 ContainerHandle* container_runtime_allocate_handle(ContainerRuntime* runtime) {
     furi_assert(runtime);
 
@@ -401,10 +437,16 @@ ContainerHandle* container_runtime_allocate_handle(ContainerRuntime* runtime) {
     furi_mutex_acquire(runtime->mutex, FuriWaitForever);
 
     if(runtime->recycled_container_pool) {
+        // Reuse from linked list if available
         handle = runtime->recycled_container_pool;
         runtime->recycled_container_pool = handle->next;
         memset(handle, 0, sizeof(ContainerHandle));
+    } else if(runtime->next_free_handle_index < CONTAINER_POOL_SIZE) {
+        // Use from static pool if available
+        handle = &runtime->container_handle_pool[runtime->next_free_handle_index++];
+        memset(handle, 0, sizeof(ContainerHandle));
     } else {
+        // Fall back to malloc only if necessary
         handle = malloc(sizeof(ContainerHandle));
         if(handle) {
             memset(handle, 0, sizeof(ContainerHandle));

furi/containerization/container_runtime.c

@@ -88,6 +88,46 @@ bool pod_manifest_validate(PodManifest* manifest);
  */
 bool pod_manifest_validate_optimized(const PodManifest* manifest);
 
+/**
+ * @brief Pod manifest validator with resource constraints check
+ * 
+ * Validates that required resources are available and pod can be scheduled.
+ * Similar to Kubernetes admission controllers.
+ * 
+ * @param manifest Pod manifest to validate
+ * @param runtime Container runtime for resource checks
+ * @return bool true if manifest is valid and can be scheduled
+ */
+bool pod_manifest_validate_resources(const PodManifest* manifest, ContainerRuntime* runtime);
+
+/**
+ * @brief Apply taints and tolerations to pod scheduling
+ * 
+ * Controls which pods can run on particular nodes/apps,
+ * similar to Kubernetes taints and tolerations.
+ * 
+ * @param manifest The pod manifest to update
+ * @param taints Array of taint specifications
+ * @param taint_count Number of taints in array
+ * @return bool true if successful
+ */
+bool pod_manifest_apply_taints(PodManifest* manifest, const PodTaint* taints, size_t taint_count);
+
+/**
+ * @brief Memory-optimized pod manifest loading
+ * 
+ * Uses streaming JSON parser to minimize memory usage while loading manifests.
+ * 
+ * @param path Path to manifest file
+ * @param buffer Working buffer for parsing
+ * @param buffer_size Size of working buffer
+ * @return PodManifest* Newly created pod manifest or NULL on failure 
+ */
+PodManifest* pod_manifest_load_from_file_buffered(
+    const char* path, 
+    char* buffer, 
+    size_t buffer_size);
+
 /**
  * @brief Batch apply multiple pod manifests
  * Similar to 'kubectl apply -f' with multiple files in Kubernetes.