fmt

Author: lovasoa

src/app_config.rs

@@ -1,3 +1,4 @@
+use crate::webserver::routing::RoutingConfig;
 use anyhow::Context;
 use clap::Parser;
 use config::Config;
@@ -6,7 +7,6 @@ use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize};
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::{Path, PathBuf};
-use crate::webserver::routing::RoutingConfig;
 
 #[derive(Parser)]
 #[clap(author, version, about, long_about = None)]

src/file_cache.rs

@@ -1,3 +1,4 @@
+use crate::webserver::routing::FileStore;
 use crate::webserver::ErrorWithStatus;
 use crate::AppState;
 use actix_web::http::StatusCode;
@@ -13,7 +14,6 @@ use std::sync::atomic::{
 use std::sync::Arc;
 use std::time::SystemTime;
 use tokio::sync::RwLock;
-use crate::webserver::routing::FileStore;
 
 /// The maximum time in milliseconds that a file can be cached before its freshness is checked
 /// (in production mode)
@@ -77,8 +77,7 @@ pub struct FileCache<T: AsyncFromStrWithState> {
 
 impl<T: AsyncFromStrWithState> FileStore for FileCache<T> {
     async fn contains(&self, path: &Path) -> anyhow::Result<bool> {
-        Ok(self.cache.read().await.contains_key(path)
-            || self.static_files.contains_key(path))
+        Ok(self.cache.read().await.contains_key(path) || self.static_files.contains_key(path))
     }
 }
 

src/filesystem.rs

@@ -132,13 +132,14 @@ impl FileSystem {
         Ok(self.local_root.join(path))
     }
 
-    pub(crate) async fn contains(&self, app_state: &AppState, path: &Path) -> anyhow::Result<bool> {
+    pub(crate) async fn file_exists(
+        &self,
+        app_state: &AppState,
+        path: &Path,
+    ) -> anyhow::Result<bool> {
         let local_exists = match self.safe_local_path(app_state, path, false) {
             Ok(safe_path) => tokio::fs::try_exists(safe_path).await?,
-            Err(e) => {
-                log::error!("Unable to check if {path:?} exists in the local filesystem: {e:#}");
-                return Err(e);
-            }
+            Err(e) => return Err(e),
         };
 
         // If not in local fs and we have db_fs, check database
@@ -158,14 +159,14 @@ async fn file_modified_since_local(path: &Path, since: DateTime<Utc>) -> tokio::
         .map(|modified_at| DateTime::<Utc>::from(modified_at) > since)
 }
 
-pub(crate) struct DbFsQueries {
+pub struct DbFsQueries {
     was_modified: AnyStatement<'static>,
     read_file: AnyStatement<'static>,
     exists: AnyStatement<'static>,
 }
 
 impl DbFsQueries {
-    fn get_create_table_sql(db_kind: AnyKind) -> &'static str {
+    pub fn get_create_table_sql(db_kind: AnyKind) -> &'static str {
         match db_kind {
             AnyKind::Mssql => "CREATE TABLE sqlpage_files(path NVARCHAR(255) NOT NULL PRIMARY KEY, contents VARBINARY(MAX), last_modified DATETIME2(3) NOT NULL DEFAULT CURRENT_TIMESTAMP);",
             AnyKind::Postgres => "CREATE TABLE IF NOT EXISTS sqlpage_files(path VARCHAR(255) NOT NULL PRIMARY KEY, contents BYTEA, last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",

src/webserver/database/mod.rs

@@ -12,7 +12,7 @@ mod sql_to_json;
 pub use sql::{make_placeholder, ParsedSqlFile};
 
 pub struct Database {
-    pub(crate) connection: sqlx::AnyPool,
+    pub connection: sqlx::AnyPool,
 }
 impl Database {
     pub async fn close(&self) -> anyhow::Result<()> {

src/webserver/http.rs

@@ -390,7 +390,9 @@ pub async fn main_handler(
     let routing_action = match calculate_route(path_and_query, &store, &app_state.config).await {
         Ok(action) => action,
         Err(e) => {
-            let e = e.context(format!("Unable to calculate the routing action for: {path_and_query:?}"));
+            let e = e.context(format!(
+                "Unable to calculate the routing action for: {path_and_query:?}"
+            ));
             return Err(anyhow_err_to_actix(e, app_state.config.environment));
         }
     };

src/webserver/routing.rs

@@ -1,6 +1,6 @@
-use crate::{file_cache::FileCache, AppState};
 use crate::filesystem::FileSystem;
 use crate::webserver::database::ParsedSqlFile;
+use crate::{file_cache::FileCache, AppState};
 use awc::http::uri::PathAndQuery;
 use log::debug;
 use std::path::{Path, PathBuf};
@@ -54,7 +54,7 @@ impl FileStore for AppFileStore<'_> {
         if self.cache.contains(path).await? {
             Ok(true)
         } else {
-            self.filesystem.contains(self.app_state, path).await
+            self.filesystem.file_exists(self.app_state, path).await
         }
     }
 }
@@ -112,7 +112,11 @@ where
     }
 }
 
-async fn find_file_or_not_found<T>(path: &Path, extension: &str, store: &T) -> anyhow::Result<RoutingAction>
+async fn find_file_or_not_found<T>(
+    path: &Path,
+    extension: &str,
+    store: &T,
+) -> anyhow::Result<RoutingAction>
 where
     T: FileStore,
 {
@@ -122,7 +126,11 @@ where
     }
 }
 
-async fn find_file<T>(path: &Path, extension: &str, store: &T) -> anyhow::Result<Option<RoutingAction>>
+async fn find_file<T>(
+    path: &Path,
+    extension: &str,
+    store: &T,
+) -> anyhow::Result<Option<RoutingAction>>
 where
     T: FileStore,
 {
@@ -426,7 +434,9 @@ mod tests {
             None => Config::default(),
             Some(value) => Config::new(value),
         };
-        calculate_route(&PathAndQuery::from_str(path).unwrap(), &store, &config).await.unwrap()
+        calculate_route(&PathAndQuery::from_str(path).unwrap(), &store, &config)
+            .await
+            .unwrap()
     }
 
     fn default_not_found() -> RoutingAction {

tests/index.rs

@@ -13,12 +13,14 @@ use actix_web::{
 };
 use sqlpage::{
     app_config::{test_database_url, AppConfig},
+    filesystem::DbFsQueries,
     webserver::{
         self,
         http::{form_config, main_handler, payload_config},
     },
     AppState,
 };
+use sqlx::Executor as _;
 
 #[actix_web::test]
 async fn test_index_ok() {
@@ -695,6 +697,74 @@ async fn test_failed_copy_followed_by_query() -> actix_web::Result<()> {
     Ok(())
 }
 
+#[actix_web::test]
+async fn test_routing_with_db_fs_and_prefix() {
+    let mut config = test_config();
+    config.site_prefix = "/prefix/".to_string();
+    let state = AppState::init(&config).await.unwrap();
+
+    // Set up database filesystem
+    let create_table_sql = DbFsQueries::get_create_table_sql(state.db.connection.any_kind());
+    state
+        .db
+        .connection
+        .execute(format!("DROP TABLE IF EXISTS sqlpage_files; {create_table_sql}").as_str())
+        .await
+        .unwrap();
+
+    // Insert test file into database
+    sqlx::query("INSERT INTO sqlpage_files(path, contents) VALUES ('tests/sql_test_files/it_works_simple.sql', 'SELECT ''It works !'' as message;')")
+        .execute(&state.db.connection)
+        .await
+        .unwrap();
+
+    let app_data = actix_web::web::Data::new(state);
+
+    // Test basic routing with prefix
+    let resp = req_path_with_app_data(
+        "/prefix/tests/sql_test_files/it_works_simple.sql",
+        app_data.clone(),
+    )
+    .await
+    .unwrap();
+    assert_eq!(resp.status(), http::StatusCode::OK);
+    let body = test::read_body(resp).await;
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert!(
+        body_str.contains("It works !"),
+        "{body_str}\nexpected to contain: It works !"
+    );
+    assert!(
+        body_str.contains("href=\"/prefix/"),
+        "{body_str}\nexpected to contain links with site prefix"
+    );
+
+    // Test 404 handling with prefix
+    let resp = req_path_with_app_data("/prefix/nonexistent.sql", app_data.clone())
+        .await
+        .expect_err("Expected 404 error")
+        .to_string();
+    assert!(resp.contains("404"));
+
+    // Test forbidden paths with prefix
+    let resp = req_path_with_app_data("/prefix/sqlpage/migrations/0001_init.sql", app_data.clone())
+        .await
+        .expect_err("Expected forbidden error")
+        .to_string();
+    assert!(resp.to_lowercase().contains("forbidden"), "{resp}");
+
+    // accessing without prefix should redirect to the prefix
+    let resp = req_path_with_app_data("/tests/sql_test_files/it_works_simple.sql", app_data)
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), http::StatusCode::MOVED_PERMANENTLY);
+    let location = resp
+        .headers()
+        .get("location")
+        .expect("location header should be present");
+    assert_eq!(location.to_str().unwrap(), "/prefix/");
+}
+
 async fn get_request_to_with_data(
     path: &str,
     data: actix_web::web::Data<AppState>,
@@ -752,7 +822,12 @@ async fn req_path_with_app_data(
     let resp = tokio::time::timeout(REQ_TIMEOUT, main_handler(req))
         .await
         .map_err(|e| anyhow::anyhow!("Request to {path} timed out: {e}"))?
-        .map_err(|e| anyhow::anyhow!("Request to {path} failed: {e}"))?;
+        .map_err(|e| {
+            anyhow::anyhow!(
+                "Request to {path} failed with status {}: {e:#}",
+                e.as_response_error().status_code()
+            )
+        })?;
     Ok(resp)
 }