Error handling

Author: UdHo

Cargo.lock

@@ -11,7 +11,6 @@ repository = "https://github.com/UdHo/mapvas.git"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-anyhow = "1.0.102"
 axum = "0.8.9"
 image = "0.25.10"
 itertools = "0.14.0"

Cargo.toml

@@ -1,6 +1,5 @@
 use crate::config::{TileProvider, TileType};
 use crate::map::coordinates::{Tile, TilePriority};
-use anyhow::Result;
 use log::{debug, error, trace};
 use regex::Regex;
 use std::cmp::Reverse;
@@ -79,15 +78,15 @@ impl Ord for PrioritizedTileRequest {
 /// The interface the cached and non-cached tile loader.
 pub trait TileLoader {
   /// Tries to fetch the tile data asyncroneously.
-  async fn tile_data(&self, tile: &Tile, source: TileSource) -> Result<TileData>;
+  async fn tile_data(&self, tile: &Tile, source: TileSource) -> Result<TileData, TileLoaderError>;
 
   /// Tries to fetch the tile data with priority.
   async fn tile_data_with_priority(
     &self,
     tile: &Tile,
     source: TileSource,
     _priority: TilePriority,
-  ) -> Result<TileData> {
+  ) -> Result<TileData, TileLoaderError> {
     // Default implementation ignores priority
     self.tile_data(tile, source).await
   }
@@ -126,20 +125,20 @@ impl TileCache {
 }
 
 impl TileLoader for TileCache {
-  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData> {
+  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData, TileLoaderError> {
     if tile_source == TileSource::Download {
-      return Err(TileLoaderError::TileNotAvailable { tile: *tile }.into());
+      return Err(TileLoaderError::TileNotAvailable { tile: *tile });
     }
     match self.path(tile) {
       Some(p) => {
         if p.exists() {
           Ok(tokio::fs::read(p).await?)
         } else {
-          Err(TileLoaderError::TileNotAvailable { tile: *tile }.into())
+          Err(TileLoaderError::TileNotAvailable { tile: *tile })
         }
       }
 
-      None => Err(TileLoaderError::TileNotAvailable { tile: *tile }.into()),
+      None => Err(TileLoaderError::TileNotAvailable { tile: *tile }),
     }
   }
 }
@@ -386,7 +385,7 @@ impl TileDownloader {
 }
 
 impl TileLoader for TileDownloader {
-  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData> {
+  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData, TileLoaderError> {
     self
       .tile_data_with_priority(tile, tile_source, TilePriority::Current)
       .await
@@ -397,17 +396,17 @@ impl TileLoader for TileDownloader {
     tile: &Tile,
     tile_source: TileSource,
     priority: TilePriority,
-  ) -> Result<TileData> {
+  ) -> Result<TileData, TileLoaderError> {
     if tile_source == TileSource::Cache {
-      return Err(TileLoaderError::TileNotAvailable { tile: *tile }.into());
+      return Err(TileLoaderError::TileNotAvailable { tile: *tile });
     }
 
     let download_token =
       DownloadManager::download_with_priority(&self.download_manager, *tile, priority)
         .or_else(|| DownloadManager::try_next_from_queue(&self.download_manager));
 
     if download_token.is_none() {
-      return Err(TileLoaderError::TileDownloadInProgress { tile: *tile }.into());
+      return Err(TileLoaderError::TileDownloadInProgress { tile: *tile });
     }
 
     let url = self.get_path_for_tile(tile);
@@ -442,7 +441,7 @@ impl TileLoader for TileDownloader {
     };
     debug!("Downloaded {tile:?}.");
 
-    Ok(result?)
+    result
   }
 }
 
@@ -520,7 +519,7 @@ impl CachedTileLoader {
     }
   }
 
-  pub async fn get_from_cache(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData> {
+  pub async fn get_from_cache(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData, TileLoaderError> {
     self.cache.tile_data(tile, tile_source).await
   }
 
@@ -539,7 +538,7 @@ impl CachedTileLoader {
     tile: &Tile,
     tile_source: TileSource,
     priority: TilePriority,
-  ) -> Result<TileData> {
+  ) -> Result<TileData, TileLoaderError> {
     match self
       .loader
       .tile_data_with_priority(tile, tile_source, priority)
@@ -548,7 +547,7 @@ impl CachedTileLoader {
       Ok(data) => {
         self.cache.cache_tile(tile, &data);
         match data.len() {
-          0..=100 => Err(TileLoaderError::TileNotAvailable { tile: *tile }.into()),
+          0..=100 => Err(TileLoaderError::TileNotAvailable { tile: *tile }),
           _ => Ok(data),
         }
       }
@@ -589,7 +588,7 @@ impl Default for CachedTileLoader {
 }
 
 impl TileLoader for CachedTileLoader {
-  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData> {
+  async fn tile_data(&self, tile: &Tile, tile_source: TileSource) -> Result<TileData, TileLoaderError> {
     self
       .tile_data_with_priority(tile, tile_source, TilePriority::Current)
       .await
@@ -600,7 +599,7 @@ impl TileLoader for CachedTileLoader {
     tile: &Tile,
     tile_source: TileSource,
     priority: TilePriority,
-  ) -> Result<TileData> {
+  ) -> Result<TileData, TileLoaderError> {
     trace!("Loading tile from file {:?}", &tile);
     if let Ok(data) = self.get_from_cache(tile, tile_source).await {
       debug!("cache_hit: {tile:?}");

src/map/tile_loader.rs

@@ -2,9 +2,17 @@ pub mod providers;
 pub mod ui;
 
 use crate::map::coordinates::WGS84Coordinate;
-use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum SearchError {
+  #[error("HTTP request failed: {0}")]
+  Http(#[from] reqwest::Error),
+  #[error("Search failed: {0}")]
+  Other(String),
+}
 
 /// A search result containing location information
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -32,15 +40,15 @@ pub trait SearchProvider: Send + Sync {
   fn name(&self) -> &str;
 
   /// Search for locations based on query string
-  async fn search(&self, query: &str) -> Result<Vec<SearchResult>>;
+  async fn search(&self, query: &str) -> Result<Vec<SearchResult>, SearchError>;
 
   /// Whether this provider supports reverse geocoding
   fn supports_reverse(&self) -> bool {
     false
   }
 
   /// Reverse geocode a coordinate to get place information
-  async fn reverse(&self, coord: WGS84Coordinate) -> Result<Option<SearchResult>> {
+  async fn reverse(&self, coord: WGS84Coordinate) -> Result<Option<SearchResult>, SearchError> {
     let _ = coord;
     Ok(None)
   }
@@ -89,7 +97,7 @@ impl SearchManager {
   ///
   /// Returns an error if any of the search providers fail to initialize,
   /// such as invalid URLs or missing required configuration parameters.
-  pub fn with_config(configs: Vec<SearchProviderConfig>) -> Result<Self> {
+  pub fn with_config(configs: Vec<SearchProviderConfig>) -> Result<Self, SearchError> {
     let mut providers: Vec<Box<dyn SearchProvider>> = Vec::new();
 
     for config in configs {
@@ -131,7 +139,7 @@ impl SearchManager {
   ///
   /// Returns an error if all search providers fail or if there are network
   /// connectivity issues preventing any searches from completing.
-  pub async fn search(&self, query: &str) -> Result<Vec<SearchResult>> {
+  pub async fn search(&self, query: &str) -> Result<Vec<SearchResult>, SearchError> {
     let query = query.trim();
     if query.is_empty() {
       return Ok(vec![]);

src/search.rs

@@ -1,6 +1,5 @@
-use super::{SearchProvider, SearchResult};
+use super::{SearchError, SearchProvider, SearchResult};
 use crate::map::coordinates::WGS84Coordinate;
-use anyhow::{Result, anyhow};
 use regex::Regex;
 use reqwest;
 use serde_json::Value;
@@ -130,7 +129,7 @@ impl SearchProvider for NominatimProvider {
     "OpenStreetMap Nominatim"
   }
 
-  async fn search(&self, query: &str) -> Result<Vec<SearchResult>> {
+  async fn search(&self, query: &str) -> Result<Vec<SearchResult>, SearchError> {
     let url = format!(
       "{}/search?format=json&limit=5&addressdetails=1&q={}",
       self.base_url,
@@ -143,10 +142,10 @@ impl SearchProvider for NominatimProvider {
       .header("User-Agent", "MapVas/0.2.8 (https://github.com/UdHo/mapvas)")
       .send()
       .await
-      .map_err(|e| anyhow!("Nominatim API request failed: {e}"))?
+      .map_err(SearchError::Http)?
       .json::<Value>()
       .await
-      .map_err(|e| anyhow!("Nominatim API response parse failed: {e}"))?;
+      .map_err(SearchError::Http)?;
 
     let mut results = Vec::new();
 
@@ -187,7 +186,7 @@ impl SearchProvider for NominatimProvider {
     true
   }
 
-  async fn reverse(&self, coord: WGS84Coordinate) -> Result<Option<SearchResult>> {
+  async fn reverse(&self, coord: WGS84Coordinate) -> Result<Option<SearchResult>, SearchError> {
     let url = format!(
       "{}/reverse?format=json&lat={}&lon={}&addressdetails=1",
       self.base_url, coord.lat, coord.lon
@@ -199,10 +198,10 @@ impl SearchProvider for NominatimProvider {
       .header("User-Agent", "MapVas/0.2.8 (https://github.com/UdHo/mapvas)")
       .send()
       .await
-      .map_err(|e| anyhow!("Nominatim reverse API request failed: {e}"))?
+      .map_err(SearchError::Http)?
       .json::<Value>()
       .await
-      .map_err(|e| anyhow!("Nominatim reverse API response parse failed: {e}"))?;
+      .map_err(SearchError::Http)?;
 
     if let Some(display_name) = response["display_name"].as_str() {
       let address = response["address"].as_object();
@@ -249,7 +248,7 @@ impl SearchProvider for CustomProvider {
     &self.name
   }
 
-  async fn search(&self, query: &str) -> Result<Vec<SearchResult>> {
+  async fn search(&self, query: &str) -> Result<Vec<SearchResult>, SearchError> {
     let url = self
       .url_template
       .replace("{query}", &urlencoding::encode(query));
@@ -262,10 +261,10 @@ impl SearchProvider for CustomProvider {
     let response = request
       .send()
       .await
-      .map_err(|e| anyhow!("Custom API request failed: {e}"))?
+      .map_err(SearchError::Http)?
       .json::<Value>()
       .await
-      .map_err(|e| anyhow!("Custom API response parse failed: {e}"))?;
+      .map_err(SearchError::Http)?;
 
     // This is a basic implementation - could be extended to support
     // different response formats based on configuration