Merge branch 'fix/ota-update' into legacy/v3-support

rust/src/webserver/mod.rs

@@ -30,59 +30,80 @@ use core::result::Result::Ok;
 use core::sync::atomic::{AtomicBool, Ordering};
 use edge_http::io::server::{Connection, Handler, Server};
 use edge_http::Method;
-use edge_nal::TcpBind;
 use edge_nal::io::{Read, Write};
+use edge_nal::TcpBind;
 use edge_nal_embassy::{Tcp, TcpBuffers};
 use embassy_net::Stack;
 use embassy_time::Instant;
-use log::info;
+use log::{error, info};
 
-// fn ota(
+pub(crate) async fn ota_operations<T, const N: usize>(
-//     request: &mut Request<&mut EspHttpConnection>,
+    conn: &mut Connection<'_, T, { N }>,
-// ) -> Result<Option<std::string::String>, anyhow::Error> {
+    method: Method,
-//     let mut board = BOARD_ACCESS.lock().unwrap();
+) -> Result<Option<u32>, FatError>
-//     let mut ota = OtaUpdate::begin()?;
+where
-//     log::info!("start ota");
+    T: Read + Write,
-//
+{
-//     //having a larger buffer is not really faster, requires more stack and prevents the progress bar from working ;)
+    Ok(match method {
-//     const BUFFER_SIZE: usize = 512;
+        Method::Options => {
-//     let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+            conn.initiate_response(
-//     let mut total_read: usize = 0;
+                200,
-//     let mut lastiter = 0;
+                Some("OK"),
-//     loop {
+                &[
-//         let read = request.read(&mut buffer)?;
+                    ("Access-Control-Allow-Origin", "*"),
-//         total_read += read;
+                    ("Access-Control-Allow-Headers", "*"),
-//         let to_write = &buffer[0..read];
+                    ("Access-Control-Allow-Methods", "*"),
-//         //delay for watchdog and wifi stuff
+                ],
-//         board.board_hal.get_esp().delay.delay_ms(1);
+            )
-//
+            .await?;
-//         let iter = (total_read / 1024) % 8;
+            Some(200)
-//         if iter != lastiter {
+        }
-//             board.board_hal.general_fault(iter % 5 == 0);
+        Method::Post => {
-//             for i in 0..PLANT_COUNT {
+            let mut offset = 0_usize;
-//                 let _ = board.board_hal.fault(i, iter == i);
+            let mut chunk = 0;
-//             }
+            loop {
-//             lastiter = iter;
+                let buf = read_up_to_bytes_from_request(conn, Some(4096)).await?;
-//         }
+                if buf.is_empty() {
-//
+                    info!("file request for  ota finished");
-//         ota.write(to_write)?;
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
-//         if read == 0 {
+                    board.board_hal.get_esp().finalize_ota().await?;
-//             break;
+                    break;
-//         }
+                } else {
-//     }
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
-//     log::info!("wrote bytes ota {total_read}");
+                    board.board_hal.progress(chunk as u32).await;
-//     log::info!("finish ota");
+                    // Erase next block if we are at a 4K boundary (including the first block at offset 0)
-//     let partition = ota.raw_partition();
+                    board
-//     log::info!("finalizing and changing boot partition to {partition:?}");
+                        .board_hal
-//
+                        .get_esp()
-//     let mut finalizer = ota.finalize()?;
+                        .write_ota(offset as u32, &buf)
-//     log::info!("changing boot partition");
+                        .await?;
-//     board.board_hal.get_esp().set_restart_to_conf(true);
+                }
-//     drop(board);
+                offset += buf.len();
-//     finalizer.set_as_boot_partition()?;
+                chunk += 1;
-//     anyhow::Ok(None)
+            }
-// }
+            BOARD_ACCESS
-//
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        _ => None,
+    })
+}
 
 struct HTTPRequestRouter {
     reboot_now: Arc<AtomicBool>,
@@ -105,7 +126,12 @@ impl Handler for HTTPRequestRouter {
         let path = headers.path;
 
         let prefix = "/file?filename=";
-        let status = if path.starts_with(prefix) {
+        let status = if path == "/ota" {
+            ota_operations(conn, method).await.map_err(|e| {
+                error!("Error handling ota: {e}");
+                e
+            })?
+        } else if path.starts_with(prefix) {
             file_operations(conn, method, &path, &prefix).await?
         } else {
             match method {
@@ -195,12 +221,18 @@ where
     let mut data_store = Vec::new();
     let mut total_read = 0;
     loop {
+        let left = max_read - total_read;
         let mut buf = [0_u8; 64];
-        let read = request.read(&mut buf).await?;
+        let s_buf = if buf.len() <= left {
+            &mut buf
+        } else {
+            &mut buf[0..left]
+        };
+        let read = request.read(s_buf).await?;
         if read == 0 {
             break;
         }
-        let actual_data = &buf[0..read];
+        let actual_data = &s_buf[0..read];
         total_read += read;
         if total_read > max_read {
             bail!("Request too large {total_read} > {max_read}");

rust/src_webpack/src/api.ts

@@ -157,7 +157,13 @@ export interface Moistures {
 export interface VersionInfo {
     git_hash: string,
     build_time: string,
-    partition: string
+    current: string,
+    slot0_state: string,
+    slot1_state: string,
+    heap_total: number,
+    heap_used: number,
+    heap_free: number,
+    heap_max_used: number,
 }
 
 export interface BatteryState {

rust/src_webpack/src/main.ts

@@ -31,6 +31,7 @@ import {
     FileList, SolarState, PumpTestResult
 } from "./api";
 import {SolarView} from "./solarview";
+import {toast} from "./toast";
 
 export class Controller {
     loadTankInfo(): Promise<void> {
@@ -200,15 +201,22 @@ export class Controller {
         }, false);
         ajax.addEventListener("load", () => {
             controller.progressview.removeProgress("ota_upload")
+            const status = ajax.status;
+            if (status >= 200 && status < 300) {
                 controller.reboot();
+            } else {
+                const statusText = ajax.statusText || "";
+                const body = ajax.responseText || "";
+                toast.error(`OTA update error (${status}${statusText ? ' ' + statusText : ''}): ${body}`);
+            }
         }, false);
         ajax.addEventListener("error", () => {
-            alert("Error ota")
             controller.progressview.removeProgress("ota_upload")
+            toast.error("OTA upload failed due to a network error.");
         }, false);
         ajax.addEventListener("abort", () => {
-            alert("abort ota")
             controller.progressview.removeProgress("ota_upload")
+            toast.error("OTA upload was aborted.");
         }, false);
         ajax.open("POST", PUBLIC_URL + "/ota");
         ajax.send(file);

rust/src_webpack/src/ota.html

@@ -2,13 +2,16 @@
     .otakey {
         min-width: 100px;
     }
+
     .otavalue {
         flex-grow: 1;
     }
+
     .otaform {
         min-width: 100px;
         flex-grow: 1;
     }
+
     .otachooser {
         min-width: 100px;
         width: 100%;
@@ -18,6 +21,7 @@
     <div class="subtitle">
         Current Firmware
     </div>
+    <button style="margin-left: auto;" type="button" id="refresh_firmware_info">Refresh</button>
 </div>
 <div class="flexcontainer">
     <span class="otakey">Buildtime:</span>
@@ -31,11 +35,43 @@
     <span class="otakey">Partition:</span>
     <span class="otavalue" id="firmware_partition"></span>
 </div>
+<div class="flexcontainer">
+    <span class="otakey">State0:</span>
+    <span class="otavalue" id="firmware_state0"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">State1:</span>
+    <span class="otavalue" id="firmware_state1"></span>
+</div>
 <div class="flexcontainer">
     <form class="otaform" id="upload_form" method="post">
         <input class="otachooser" type="file" name="file1" id="firmware_file"><br>
     </form>
 </div>
+<div class="flexcontainer">
+    <div class="subtitle">
+        Heap Memory
+    </div>
+    <div></div>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Free:</span>
+    <span class="otavalue" id="heap_free"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Used:</span>
+    <span class="otavalue" id="heap_used"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Total:</span>
+    <span class="otavalue" id="heap_total"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Peak used:</span>
+    <span class="otavalue" id="heap_max_used"></span>
+</div>
+
+
 <div class="display:flex">
     <button style="margin-left: 16px; margin-top: 8px;" class="col-6" type="button" id="test">Self-Test</button>
 </div>

rust/src_webpack/src/ota.ts

@@ -1,21 +1,37 @@
 import {Controller} from "./main";
 import {VersionInfo} from "./api";
 
+function fmtBytes(n: number): string {
+    return `${n} B (${(n / 1024).toFixed(1)} KiB)`;
+}
+
 export class OTAView {
     readonly file1Upload: HTMLInputElement;
     readonly firmware_buildtime: HTMLDivElement;
     readonly firmware_githash: HTMLDivElement;
     readonly firmware_partition: HTMLDivElement;
+    readonly firmware_state0: HTMLDivElement;
+    readonly firmware_state1: HTMLDivElement;
+    readonly heap_free: HTMLDivElement;
+    readonly heap_used: HTMLDivElement;
+    readonly heap_total: HTMLDivElement;
+    readonly heap_max_used: HTMLDivElement;
 
     constructor(controller: Controller) {
         (document.getElementById("firmwareview") as HTMLElement).innerHTML = require("./ota.html")
 
         let test = document.getElementById("test") as HTMLButtonElement;
+        let refresh = document.getElementById("refresh_firmware_info") as HTMLButtonElement;
 
         this.firmware_buildtime = document.getElementById("firmware_buildtime") as HTMLDivElement;
         this.firmware_githash = document.getElementById("firmware_githash") as HTMLDivElement;
         this.firmware_partition = document.getElementById("firmware_partition") as HTMLDivElement;
-
+        this.firmware_state0 = document.getElementById("firmware_state0") as HTMLDivElement;
+        this.firmware_state1 = document.getElementById("firmware_state1") as HTMLDivElement;
+        this.heap_free = document.getElementById("heap_free") as HTMLDivElement;
+        this.heap_used = document.getElementById("heap_used") as HTMLDivElement;
+        this.heap_total = document.getElementById("heap_total") as HTMLDivElement;
+        this.heap_max_used = document.getElementById("heap_max_used") as HTMLDivElement;
 
         const file = document.getElementById("firmware_file") as HTMLInputElement;
         this.file1Upload = file
@@ -31,11 +47,21 @@ export class OTAView {
         test.onclick = () => {
             controller.selfTest();
         }
+
+        refresh.onclick = () => {
+            controller.version();
+        }
     }
 
     setVersion(versionInfo: VersionInfo) {
         this.firmware_buildtime.innerText = versionInfo.build_time;
         this.firmware_githash.innerText = versionInfo.git_hash;
-        this.firmware_partition.innerText = versionInfo.partition;
+        this.firmware_partition.innerText = versionInfo.current;
+        this.firmware_state0.innerText = versionInfo.slot0_state;
+        this.firmware_state1.innerText = versionInfo.slot1_state;
+        this.heap_free.innerText = fmtBytes(versionInfo.heap_free);
+        this.heap_used.innerText = fmtBytes(versionInfo.heap_used);
+        this.heap_total.innerText = fmtBytes(versionInfo.heap_total);
+        this.heap_max_used.innerText = fmtBytes(versionInfo.heap_max_used);
     }
 }

rust/src_webpack/src/toast.ts

@@ -0,0 +1,94 @@
+class ToastService {
+  private container: HTMLElement;
+  private stylesInjected = false;
+
+  constructor() {
+    this.container = this.ensureContainer();
+    this.injectStyles();
+  }
+
+  info(message: string, timeoutMs: number = 5000) {
+    const el = this.createToast(message, 'info');
+    this.container.appendChild(el);
+    // Auto-dismiss after timeout
+    const timer = window.setTimeout(() => this.dismiss(el), timeoutMs);
+    // Dismiss on click immediately
+    el.addEventListener('click', () => {
+      window.clearTimeout(timer);
+      this.dismiss(el);
+    });
+  }
+
+  error(message: string) {
+    console.error(message);
+    const el = this.createToast(message, 'error');
+    this.container.appendChild(el);
+    // Only dismiss on click
+    el.addEventListener('click', () => this.dismiss(el));
+  }
+
+  private dismiss(el: HTMLElement) {
+    if (!el.parentElement) return;
+    el.parentElement.removeChild(el);
+  }
+
+  private createToast(message: string, type: 'info' | 'error'): HTMLElement {
+    const div = document.createElement('div');
+    div.className = `toast ${type}`;
+    div.textContent = message;
+    div.setAttribute('role', 'status');
+    div.setAttribute('aria-live', 'polite');
+    return div;
+  }
+
+  private ensureContainer(): HTMLElement {
+    let container = document.getElementById('toast-container');
+    if (!container) {
+      container = document.createElement('div');
+      container.id = 'toast-container';
+      document.body.appendChild(container);
+    }
+    return container;
+  }
+
+  private injectStyles() {
+    if (this.stylesInjected) return;
+    const style = document.createElement('style');
+    style.textContent = `
+#toast-container {
+  position: fixed;
+  top: 12px;
+  right: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  z-index: 9999;
+}
+.toast {
+  max-width: 320px;
+  padding: 10px 12px;
+  border-radius: 6px;
+  box-shadow: 0 2px 6px rgba(0,0,0,0.2);
+  cursor: pointer;
+  user-select: none;
+  font-family: sans-serif;
+  font-size: 14px;
+  line-height: 1.3;
+}
+.toast.info {
+  background-color: #d4edda; /* green-ish */
+  color: #155724;
+  border-left: 4px solid #28a745;
+}
+.toast.error {
+  background-color: #f8d7da; /* red-ish */
+  color: #721c24;
+  border-left: 4px solid #dc3545;
+}
+`;
+    document.head.appendChild(style);
+    this.stylesInjected = true;
+  }
+}
+
+export const toast = new ToastService();