niklas/fw-anwesenheit
1
0
Fork 0
mirror of https://github.com/Djeeberjr/fw-anwesenheit.git synced 2025-11-04 15:44:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

improved error handeling for sdcard functions

Browse Source
This commit is contained in:
Djeeberjr 2025-11-03 18:35:10 +01:00
parent 07d51264f9
commit 02798d90c4
6 changed files with 206 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
src/init/sd_card.rs
View File

@ -1,10 +1,12 @@
use core::str::from_utf8;
use alloc::{string::ToString, vec::Vec};
use core::str::from_utf8;
use embassy_time::Delay;
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_sdmmc::{SdCard, ShortFileName, TimeSource, Timestamp, VolumeIdx, VolumeManager};
use embedded_sdmmc::{
SdCard, SdCardError, ShortFileName, TimeSource, Timestamp, VolumeIdx, VolumeManager,
};
use esp_hal::{Blocking, gpio::Output, spi::master::Spi};
use thiserror::Error;
use crate::store::{
AttendanceDay, day::Day, mapping_loader::Name, persistence::Persistence, tally_id::TallyID,
@ -45,190 +47,229 @@ pub struct SDCardPersistence {
impl SDCardPersistence {
const MAPPING_DIRNAME: &'static str = "MAPPINGS";
fn generate_filename_for_day(day: Day) -> ShortFileName {
fn generate_filename_for_day(day: Day) -> Result<ShortFileName, PersistenceError> {
let basename = day.to_string();
let mut filename: heapless::String<11> = heapless::String::new();
filename.push_str(&basename).unwrap();
filename.push_str(".JS").unwrap();
filename
.push_str(&basename)
.map_err(|_| PersistenceError::DayFilename)?;
filename
.push_str(".JS")
.map_err(|_| PersistenceError::DayFilename)?;
ShortFileName::create_from_str(&filename).unwrap()
ShortFileName::create_from_str(&filename).map_err(|_| PersistenceError::DayFilename)
}
fn generate_path_for_id(id: TallyID) -> (ShortFileName, ShortFileName) {
fn generate_path_for_id(
id: TallyID,
) -> Result<(ShortFileName, ShortFileName), PersistenceError> {
let basename: heapless::String<12> = id.into();
let (dir, file) = basename.split_at(6);
let mut filename: heapless::String<11> = heapless::String::new();
filename.push_str(file).unwrap();
filename.push_str(".JS").unwrap();
filename
.push_str(file)
.map_err(|_| PersistenceError::IDFilename)?;
filename
.push_str(".JS")
.map_err(|_| PersistenceError::IDFilename)?;
let mut dirname: heapless::String<11> = heapless::String::new();
dirname.push_str(dir).unwrap();
dirname
.push_str(dir)
.map_err(|_| PersistenceError::IDFilename)?;
(
ShortFileName::create_from_str(&dirname).unwrap(),
ShortFileName::create_from_str(&filename).unwrap(),
)
Ok((
ShortFileName::create_from_str(&dirname).map_err(|_| PersistenceError::IDFilename)?,
ShortFileName::create_from_str(&filename).map_err(|_| PersistenceError::IDFilename)?,
))
}
fn get_tallyid_from_path(dirname: &ShortFileName, filename: &ShortFileName) -> Option<TallyID> {
fn get_tallyid_from_path(
dirname: &ShortFileName,
filename: &ShortFileName,
) -> Result<TallyID, PersistenceError> {
let mut id_str: heapless::String<12> = heapless::String::new();
id_str.push_str(&dirname.to_string()).unwrap();
id_str
.push_str(from_utf8(filename.base_name()).unwrap())
.unwrap();
.push_str(&dirname.to_string())
.map_err(|_| PersistenceError::IDFilename)?;
id_str
.push_str(from_utf8(filename.base_name()).map_err(|_| PersistenceError::IDFilename)?)
.map_err(|_| PersistenceError::IDFilename)?;
let id: TallyID = id_str.try_into().unwrap();
let id: TallyID = id_str
.try_into()
.map_err(|_| PersistenceError::IDFilename)?;
Some(id)
Ok(id)
}
}
#[derive(Error, Debug)]
pub enum PersistenceError {
#[error("Failed to interact with SD card")]
SdCard(embedded_sdmmc::Error<SdCardError>),
#[error("Failed to parse data")]
Parseing(#[from] serde_json::Error),
#[error("Failed to parse Day and Filename")]
DayFilename,
#[error("Failed to parse TallyID for file path")]
IDFilename,
#[error("Item not found")]
NotFound,
}
impl From<embedded_sdmmc::Error<SdCardError>> for PersistenceError {
fn from(err: embedded_sdmmc::Error<SdCardError>) -> Self {
PersistenceError::SdCard(err)
}
}
impl Persistence for SDCardPersistence {
async fn load_day(&mut self, day: Day) -> Option<AttendanceDay> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
type Error = PersistenceError;
let filename = Self::generate_filename_for_day(day);
async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let filename = Self::generate_filename_for_day(day)?;
let file = root_dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadOnly);
if file.is_err() {
return None;
return Err(PersistenceError::NotFound);
}
let mut open_file = file.unwrap();
let mut open_file = file?;
let mut read_buffer: [u8; 1024] = [0; 1024];
let read = open_file.read(&mut read_buffer).unwrap();
open_file.close().unwrap();
let read = open_file.read(&mut read_buffer)?;
open_file.close()?;
let day: AttendanceDay = serde_json::from_slice(&read_buffer[..read]).unwrap();
let day: AttendanceDay = serde_json::from_slice(&read_buffer[..read])?;
Some(day)
Ok(day)
}
async fn save_day(&mut self, day: Day, data: &AttendanceDay) {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
async fn save_day(&mut self, day: Day, data: &AttendanceDay) -> Result<(), Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let filename = Self::generate_filename_for_day(day);
let filename = Self::generate_filename_for_day(day)?;
let mut file = root_dir
.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)
.unwrap();
let mut file =
root_dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)?;
file.write(&serde_json::to_vec(data).unwrap()).unwrap();
file.write(&serde_json::to_vec(data)?)?;
file.flush().unwrap();
file.close().unwrap();
file.flush()?;
file.close()?;
Ok(())
}
async fn list_days(&mut self) -> Vec<Day> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
async fn list_days(&mut self) -> Result<Vec<Day>, Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let mut days_dir = root_dir.open_dir(".").unwrap();
let mut days_dir = root_dir.open_dir(".")?;
let mut days: Vec<Day> = Vec::new();
days_dir
.iterate_dir(|e| {
let filename = e.name.clone();
days_dir.iterate_dir(|e| {
let filename = e.name.clone();
if let Ok(day) = filename.try_into() {
days.push(day);
}
})
.unwrap();
if let Ok(day) = filename.try_into() {
days.push(day);
}
})?;
days
Ok(days)
}
async fn load_mapping_for_id(
&mut self,
id: crate::store::tally_id::TallyID,
) -> Option<crate::store::mapping_loader::Name> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME).unwrap();
) -> Result<crate::store::mapping_loader::Name, Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
let (dirname, filename) = Self::generate_path_for_id(id);
let (dirname, filename) = Self::generate_path_for_id(id)?;
let mut dir = mapping_dir.open_dir(dirname).unwrap();
let mut file = dir
.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadOnly)
.unwrap();
let mut dir = mapping_dir.open_dir(dirname)?;
let mut file = dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadOnly)?;
let mut read_buffer: [u8; 1024] = [0; 1024];
let read_bytes = file.read(&mut read_buffer).unwrap();
file.close().unwrap();
let read_bytes = file.read(&mut read_buffer)?;
file.close()?;
let mapping: Name = serde_json::from_slice(&read_buffer[..read_bytes]).unwrap();
let mapping: Name = serde_json::from_slice(&read_buffer[..read_bytes])?;
Some(mapping)
Ok(mapping)
}
async fn save_mapping_for_id(
&mut self,
id: crate::store::tally_id::TallyID,
name: crate::store::mapping_loader::Name,
) {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME).unwrap();
) -> Result<(), Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
let (dirname, filename) = Self::generate_path_for_id(id);
let (dirname, filename) = Self::generate_path_for_id(id)?;
let mut dir = if let Ok(dir) = mapping_dir.open_dir(&dirname) {
dir
} else {
mapping_dir.make_dir_in_dir(&dirname).unwrap();
mapping_dir.open_dir(&dirname).unwrap()
mapping_dir.make_dir_in_dir(&dirname)?;
mapping_dir.open_dir(&dirname)?
};
let mut file = dir
.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)
.unwrap();
let mut file =
dir.open_file_in_dir(filename, embedded_sdmmc::Mode::ReadWriteCreateOrTruncate)?;
file.write(&serde_json::to_vec(&name).unwrap()).unwrap();
file.write(&serde_json::to_vec(&name)?)?;
Ok(())
}
async fn list_mappings(&mut self) -> Vec<TallyID> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0)).unwrap();
let mut root_dir = vol_0.open_root_dir().unwrap();
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME).unwrap();
async fn list_mappings(&mut self) -> Result<Vec<TallyID>, Self::Error> {
let mut vol_0 = self.vol_mgr.open_volume(VolumeIdx(0))?;
let mut root_dir = vol_0.open_root_dir()?;
let mut mapping_dir = root_dir.open_dir(Self::MAPPING_DIRNAME)?;
let mut ids: Vec<TallyID> = Vec::new();
let mut dir_names = Vec::new();
mapping_dir
.iterate_dir(|entry| {
if entry.attributes.is_directory()
&& entry.name.to_string() != "."
&& entry.name.to_string() != ".."
{
dir_names.push(entry.name.clone());
}
})
.unwrap();
mapping_dir.iterate_dir(|entry| {
if entry.attributes.is_directory()
&& entry.name.to_string() != "."
&& entry.name.to_string() != ".."
{
dir_names.push(entry.name.clone());
}
})?;
for dirname in dir_names {
if let Ok(mut subdir) = mapping_dir.open_dir(&dirname) {
let mut file_names = Vec::new();
subdir
.iterate_dir(|file_entry| {
if !file_entry.attributes.is_directory() {
file_names.push(file_entry.name.clone());
}
})
.unwrap();
subdir.iterate_dir(|file_entry| {
if !file_entry.attributes.is_directory() {
file_names.push(file_entry.name.clone());
}
})?;
for filename in file_names {
let id = Self::get_tallyid_from_path(&dirname, &filename);
ids.push(id.unwrap());
let id = Self::get_tallyid_from_path(&dirname, &filename)?;
ids.push(id);
}
}
}
ids
Ok(ids)
}
}

1
src/main.rs
View File

@ -2,6 +2,7 @@
#![no_main]
#![feature(type_alias_impl_trait)]
#![feature(impl_trait_in_assoc_type)]
#![warn(clippy::unwrap_used)]
use alloc::rc::Rc;
use embassy_executor::Spawner;

18
src/store/id_store.rs
View File

@ -58,7 +58,7 @@ impl<T: Persistence> IDStore<T> {
}
}
async fn persist_day(&mut self) {
async fn persist_day(&mut self) -> Result<(), T::Error> {
self.persistence_layer
.lock()
.await
@ -88,21 +88,25 @@ impl<T: Persistence> IDStore<T> {
}
/// Load and return a AttendanceDay. Nothing more. Nothing less.
pub async fn load_day(&mut self, day: Day) -> Option<AttendanceDay> {
pub async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, T::Error> {
if day == self.current_day.date {
return Some(self.current_day.clone());
return Ok(self.current_day.clone());
}
self.persistence_layer.lock().await.load_day(day).await
}
pub async fn list_days_in_timespan(&mut self, from: Day, to: Day) -> Vec<Day> {
let all_days = self.persistence_layer.lock().await.list_days().await;
pub async fn list_days_in_timespan(
&mut self,
from: Day,
to: Day,
) -> Result<Vec<Day>, T::Error> {
let all_days = self.persistence_layer.lock().await.list_days().await?;
all_days
Ok(all_days
.into_iter()
.filter(|e| *e >= from)
.filter(|e| *e <= to)
.collect()
.collect())
}
}

8
src/store/mapping_loader.rs
View File

@ -17,15 +17,15 @@ impl<T: Persistence> MappingLoader<T> {
Self(persistence_layer)
}
pub async fn get_mapping(&self, id: TallyID) -> Option<Name> {
pub async fn get_mapping(&self, id: TallyID) -> Result<Name, T::Error> {
self.0.lock().await.load_mapping_for_id(id).await
}
pub async fn set_mapping(&self, id: TallyID, name: Name) {
self.0.lock().await.save_mapping_for_id(id, name).await;
pub async fn set_mapping(&self, id: TallyID, name: Name) -> Result<(), T::Error> {
self.0.lock().await.save_mapping_for_id(id, name).await
}
pub async fn list_mappings(&self) -> Vec<TallyID> {
pub async fn list_mappings(&self) -> Result<Vec<TallyID>,T::Error> {
self.0.lock().await.list_mappings().await
}
}

14
src/store/persistence.rs
View File

@ -3,11 +3,13 @@ use alloc::vec::Vec;
use crate::store::{day::Day, id_store::AttendanceDay, mapping_loader::Name, tally_id::TallyID};
pub trait Persistence {
async fn load_day(&mut self, day: Day) -> Option<AttendanceDay>;
async fn save_day(&mut self, day: Day, data: &AttendanceDay);
async fn list_days(&mut self) -> Vec<Day>;
type Error: core::error::Error;
async fn load_mapping_for_id(&mut self, id:TallyID ) -> Option<Name>;
async fn save_mapping_for_id(&mut self, id:TallyID, name: Name);
async fn list_mappings(&mut self) -> Vec<TallyID>;
async fn load_day(&mut self, day: Day) -> Result<AttendanceDay, Self::Error>;
async fn save_day(&mut self, day: Day, data: &AttendanceDay) -> Result<(), Self::Error>;
async fn list_days(&mut self) -> Result<Vec<Day>, Self::Error>;
async fn load_mapping_for_id(&mut self, id: TallyID) -> Result<Name, Self::Error>;
async fn save_mapping_for_id(&mut self, id: TallyID, name: Name) -> Result<(), Self::Error>;
async fn list_mappings(&mut self) -> Result<Vec<TallyID>, Self::Error>;
}

50
src/webserver/api.rs
View File

@ -34,19 +34,34 @@ pub struct QueryMapping {
}
// GET /api/mappings
pub async fn get_mappings(State(state): State<AppState>) -> impl IntoResponse {
pub async fn get_mappings(
State(state): State<AppState>,
) -> Result<impl IntoResponse, impl IntoResponse> {
let loader = state.mapping_loader.lock().await;
response::Json(loader.list_mappings().await)
match loader.list_mappings().await {
Ok(ids) => Ok(response::Json(ids)),
Err(_) => Err((
response::StatusCode::INTERNAL_SERVER_ERROR,
"INTERNAL_SERVER_ERROR",
)),
}
}
// GET /api/mapping
pub async fn get_mapping(
State(state): State<AppState>,
Query(QueryMapping { id }): Query<QueryMapping>,
) -> impl IntoResponse {
) -> Result<impl IntoResponse, impl IntoResponse> {
let loader = state.mapping_loader.lock().await;
let mapping = loader.get_mapping(id).await;
response::Json(mapping)
match loader.get_mapping(id).await {
Ok(name) => Ok(response::Json(name)),
Err(_) => Err((
response::StatusCode::INTERNAL_SERVER_ERROR,
"INTERNAL_SERVER_ERROR",
)),
}
}
// POST /api/mapping
@ -55,7 +70,13 @@ pub async fn add_mapping(
Json(data): Json<NewMapping>,
) -> impl IntoResponse {
let loader = state.mapping_loader.lock().await;
loader.set_mapping(data.id, data.name).await;
match loader.set_mapping(data.id, data.name).await {
Ok(_) => (response::StatusCode::CREATED, ""),
Err(_) => (
response::StatusCode::INTERNAL_SERVER_ERROR,
"INTERNAL_SERVER_ERROR",
),
}
}
// SSE /api/idevent
@ -84,9 +105,13 @@ pub async fn get_days(
let mut store = state.store.lock().await;
let days = store.list_days_in_timespan(from_day, to_day).await;
response::Json(days)
match store.list_days_in_timespan(from_day, to_day).await {
Ok(days) => Ok(response::Json(days)),
Err(_) => Err((
response::StatusCode::INTERNAL_SERVER_ERROR,
"Internal server error",
)),
}
}
// GET /api/day
@ -102,7 +127,10 @@ pub async fn get_day(
let mut store = state.store.lock().await;
match store.load_day(parsed_day).await {
Some(att_day) => Ok(response::Json(att_day)),
None => Err((response::StatusCode::NOT_FOUND, "Not found")),
Ok(att_day) => Ok(response::Json(att_day)),
Err(_) => Err((
response::StatusCode::INTERNAL_SERVER_ERROR,
"Internal server error",
)),
}
}