cleanup reboot logic, fix json upload

rust/src/webserver/webserver.rs

@@ -4,8 +4,6 @@ use std::{
     str::from_utf8,
     sync::{atomic::AtomicBool, Arc},
 };
-
-use esp_idf_svc::io::BufRead;
 use crate::{
     espota::OtaUpdate, get_version, map_range_moisture, plant_hal::FileInfo, BOARD_ACCESS,
 };
@@ -56,11 +54,8 @@ pub struct TestPump {
 fn write_time(
     request: &mut Request<&mut EspHttpConnection>,
 ) -> Result<Option<std::string::String>, anyhow::Error> {
-    let mut buf = [0_u8; 3072];
-    let read = request.read(&mut buf)?;
-    let actual_data = &buf[0..read];
-    println!("Raw data {}", from_utf8(actual_data)?);
-    let time: SetTime = serde_json::from_slice(actual_data)?;
+    let actual_data = read_up_to_bytes_from_request(request, None)?;
+    let time: SetTime = serde_json::from_slice(&actual_data)?;
     let parsed = DateTime::parse_from_rfc3339(time.time).map_err(|err| anyhow::anyhow!(err))?;
     let mut board = BOARD_ACCESS.lock().unwrap();
     board.set_rtc_time(&parsed.to_utc())?;
@@ -144,16 +139,14 @@ fn get_config(
 fn set_config(
     request: &mut Request<&mut EspHttpConnection>,
 ) -> Result<Option<std::string::String>, anyhow::Error> {
-    let mut buf = [0_u8; 3072];
-    let read = request.read(&mut buf)?;
-    let actual_data = &buf[0..read];
-    println!("Raw data {}", from_utf8(actual_data).unwrap());
-    let config: PlantControllerConfig = serde_json::from_slice(actual_data)?;
+    let all = read_up_to_bytes_from_request(request, Some(3072))?;
+    let config: PlantControllerConfig = serde_json::from_slice(&all)?;
     let mut board = BOARD_ACCESS.lock().unwrap();
     board.set_config(&config)?;
     anyhow::Ok(Some("saved".to_owned()))
 }
 
+
 fn get_battery_state(
     _request: &mut Request<&mut EspHttpConnection>,
 ) -> Result<Option<std::string::String>, anyhow::Error> {
@@ -172,9 +165,8 @@ fn get_version_web(
 fn pump_test(
     request: &mut Request<&mut EspHttpConnection>,
 ) -> Result<Option<std::string::String>, anyhow::Error> {
-    let mut buf = [0_u8; 3072];
-    let read = request.read(&mut buf)?;
-    let pump_test: TestPump = serde_json::from_slice(&buf[0..read])?;
+    let actual_data = read_up_to_bytes_from_request(request, None)?;
+    let pump_test: TestPump = serde_json::from_slice(&actual_data)?;
     let mut board = BOARD_ACCESS.lock().unwrap();
     board.test_pump(pump_test.pump)?;
     anyhow::Ok(None)
@@ -285,7 +277,7 @@ fn query_param(uri: &str, param_name: &str) -> Option<std::string::String> {
     }
 }
 
-pub fn httpd(_reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
+pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
     let server_config = Configuration {
         stack_size: 32768,
         ..Default::default()
@@ -358,6 +350,25 @@ pub fn httpd(_reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
             handle_error_to500(request, list_files)
         })
         .unwrap();
+    let reboot_now_for_reboot = reboot_now.clone();
+    server
+    .fn_handler("/reboot", Method::Post, move |_| {
+        BOARD_ACCESS
+            .lock()
+            .unwrap()
+            .set_restart_to_conf(true);
+        reboot_now_for_reboot.store(true, std::sync::atomic::Ordering::Relaxed);             
+        anyhow::Ok(())
+    })
+    .unwrap();
+
+    let reboot_now_for_exit = reboot_now.clone();
+    server
+    .fn_handler("/exit", Method::Post, move |_| {
+        reboot_now_for_exit.store(true, std::sync::atomic::Ordering::Relaxed);       
+        anyhow::Ok(())
+    })
+    .unwrap();
     server
         .fn_handler("/file", Method::Get, move |request| {
             let filename = query_param(request.uri(), "filename").unwrap();
@@ -407,6 +418,8 @@ pub fn httpd(_reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
                 .unwrap()
                 .get_file_handle(&filename, true);
             match file_handle {
+                //TODO get free filesystem size, check against during write if not to large
+
                 Ok(mut file_handle) => {
                     const BUFFER_SIZE: usize = 512;
                     let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
@@ -482,7 +495,6 @@ pub fn httpd(_reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
             anyhow::Ok(())
         })
         .unwrap();
-
     server
         .fn_handler("/", Method::Get, move |request| {
             let mut response = request.into_ok_response()?;
@@ -559,3 +571,25 @@ fn handle_error_to500(
     }
     return anyhow::Ok(());
 }
+
+fn read_up_to_bytes_from_request(request: &mut Request<&mut EspHttpConnection<'_>>, limit: Option<usize>) -> Result<Vec<u8>, anyhow::Error> {
+    let max_read = limit.unwrap_or(1024);
+    let mut data_store = Vec::new();
+    let mut total_read = 0;
+    loop{
+        let mut buf = [0_u8; 64];
+        let read = request.read(&mut buf)?;
+        if read == 0 {
+            break;
+        }
+        let actual_data = &buf[0..read];
+        total_read += read;
+        if total_read > max_read{
+            bail!("Request too large {total_read} > {max_read}");
+        }
+        data_store.push(actual_data.to_owned());
+    }
+    let allvec = data_store.concat();
+    println!("Raw data {}", from_utf8(&allvec)?);
+    Ok(allvec)
+}