#13 authorize search endpoint, add public mode

Author: joepio

CHANGELOG.md

@@ -7,6 +7,7 @@ By far most changes relate to `atomic-server`, so if not specified, assume the c
 
 - Add authentication to restrict read access. Works by signing requests with Private Keys. #13
 - Refactor internal error model, Use correct HTTP status codes #11
+- Add `public-mode` to server, to keep performance maximum if you don't want authentication.
 
 ## v0.28.2
 

lib/src/lib.rs

@@ -77,6 +77,8 @@ pub use atoms::Atom;
 pub use commit::Commit;
 #[cfg(feature = "db")]
 pub use db::Db;
+pub use errors::AtomicError;
+pub use errors::AtomicErrorType;
 pub use resources::Resource;
 pub use store::Store;
 pub use storelike::Storelike;

server/src/config.rs

@@ -38,8 +38,8 @@ pub struct Opts {
     /// The IP address of the server
     #[clap(long, default_value = "0.0.0.0", env = "ATOMIC_IP")]
     pub ip: IpAddr,
-    /// If we're using HTTPS or plaintext HTTP.
-    /// Is disabled when using cert_init
+    /// Use HTTPS instead of HTTP.
+    /// Will get certificates from LetsEncrypt.
     #[clap(long, env = "ATOMIC_HTTPS")]
     pub https: bool,
     /// Endpoint where the front-end assets are hosted
@@ -55,12 +55,15 @@ pub struct Opts {
     /// Path for atomic data config directory. Defaults to "~/.config/atomic/""
     #[clap(long, env = "ATOMIC_CONFIG_DIR")]
     pub config_dir: Option<PathBuf>,
-    /// When enabled, it allows POSTing to the /search endpoint
+    /// CAUTION: Makes data public on the `/search` endpoint. When enabled, it allows POSTing to the /search endpoint and returns search results as single triples, without performing authentication checks. See https://github.com/joepio/atomic-data-rust/blob/master/server/rdf-search.md
     #[clap(long, env = "ATOMIC_RDF_SEARCH")]
     pub rdf_search: bool,
-    /// When enabled, previous versions of resources are removed from the search index when updated.
+    /// By default, Atomic-Server keeps previous verions of resources indexed in Search. When enabling this flag, previous versions of resources are removed from the search index when their values are updated.
     #[clap(long, env = "ATOMIC_REMOVE_PREVIOUS_SEARCH")]
     pub remove_previous_search: bool,
+    /// CAUTION: Skip authentication checks, making all data public. Improves performance.
+    #[clap(long, env = "ATOMIC_PUBLIC_MODE")]
+    pub public_mode: bool,
 }
 
 #[derive(Parser, Clone, Debug)]

server/src/errors.rs

@@ -20,29 +20,7 @@ pub struct AtomicServerError {
     pub error_type: AppErrorType,
 }
 
-impl AtomicServerError {
-    #[allow(dead_code)]
-    pub fn not_found(message: String) -> AtomicServerError {
-        AtomicServerError {
-            message: format!("Resource not found. {}", message),
-            error_type: AppErrorType::NotFound,
-        }
-    }
-
-    pub fn unauthorized(message: String) -> AtomicServerError {
-        AtomicServerError {
-            message: format!("Unauthorized. {}", message),
-            error_type: AppErrorType::Unauthorized,
-        }
-    }
-
-    pub fn other_error(message: String) -> AtomicServerError {
-        AtomicServerError {
-            message,
-            error_type: AppErrorType::Other,
-        }
-    }
-}
+impl AtomicServerError {}
 
 #[derive(Serialize)]
 pub struct AppErrorResponse {
@@ -145,6 +123,15 @@ impl From<acme_lib::Error> for AtomicServerError {
     }
 }
 
+impl From<actix_web::Error> for AtomicServerError {
+    fn from(error: actix_web::Error) -> Self {
+        AtomicServerError {
+            message: error.to_string(),
+            error_type: AppErrorType::Other,
+        }
+    }
+}
+
 impl From<atomic_lib::errors::AtomicError> for AtomicServerError {
     fn from(error: atomic_lib::errors::AtomicError) -> Self {
         println!("ERROR: {:?}", error);

server/src/handlers/resource.rs

@@ -1,6 +1,6 @@
 use crate::{
     appstate::AppState, content_types::get_accept, content_types::ContentType,
-    errors::AtomicServerResult, helpers::get_auth_headers,
+    errors::AtomicServerResult, helpers::get_client_agent,
 };
 use actix_web::{web, HttpResponse};
 use atomic_lib::Storelike;
@@ -13,11 +13,11 @@ pub async fn get_resource(
     data: web::Data<Mutex<AppState>>,
     req: actix_web::HttpRequest,
 ) -> AtomicServerResult<HttpResponse> {
-    let context = data.lock().unwrap();
+    let appstate = data.lock().unwrap();
 
     let headers = req.headers();
     let mut content_type = get_accept(headers);
-    let base_url = &context.config.local_base_url;
+    let base_url = &appstate.config.local_base_url;
     // Get the subject from the path, or return the home URL
     let subject = if let Some(subj_end) = path {
         let mut subj_end_string = subj_end.as_str();
@@ -40,13 +40,9 @@ pub async fn get_resource(
         String::from(base_url)
     };
 
-    let store = &context.store;
-
-    // Authentication check. If the user has no headers, continue with the Public Agent.
-    let auth_header_values = get_auth_headers(headers, subject.clone())?;
-    let for_agent =
-        atomic_lib::authentication::get_agent_from_headers_and_check(auth_header_values, store)?;
+    let store = &appstate.store;
 
+    let for_agent = get_client_agent(headers, &appstate, subject.clone())?;
     let mut builder = HttpResponse::Ok();
     log::info!("get_resource: {} as {}", subject, content_type.to_mime());
     builder.header("Content-Type", content_type.to_mime());
@@ -56,7 +52,7 @@ pub async fn get_resource(
         "Cache-Control",
         "no-store, no-cache, must-revalidate, private",
     );
-    let resource = store.get_resource_extended(&subject, false, Some(for_agent))?;
+    let resource = store.get_resource_extended(&subject, false, for_agent)?;
     match content_type {
         ContentType::Json => {
             let body = resource.to_json(store)?;

server/src/handlers/search.rs

@@ -23,13 +23,13 @@ pub async fn search_query(
     params: web::Query<SearchQuery>,
     req: actix_web::HttpRequest,
 ) -> AtomicServerResult<HttpResponse> {
-    let context = data
+    let appstate = data
         .lock()
         .expect("Failed to lock mutexguard in search_query");
 
-    let store = &context.store;
-    let searcher = context.search_state.reader.searcher();
-    let fields = crate::search::get_schema_fields(&context.search_state)?;
+    let store = &appstate.store;
+    let searcher = appstate.search_state.reader.searcher();
+    let fields = crate::search::get_schema_fields(&appstate.search_state)?;
     let default_limit = 30;
     let limit = if let Some(l) = params.limit {
         if l > 0 {
@@ -46,7 +46,6 @@ pub async fn search_query(
         // Fuzzy searching is not possible when filtering by property
         should_fuzzy = false;
     }
-    let return_subjects = !params.include.unwrap_or(false);
 
     let mut subjects: Vec<String> = Vec::new();
     let mut atoms: Vec<StringAtom> = Vec::new();
@@ -67,7 +66,7 @@ pub async fn search_query(
         } else {
             // construct the query
             let query_parser = QueryParser::for_index(
-                &context.search_state.index,
+                &appstate.search_state.index,
                 vec![
                     fields.subject,
                     // I don't think we need to search in the property
@@ -133,7 +132,7 @@ pub async fn search_query(
             .ok_or("Add a query param")?
             .to_string()
     );
-    let mut results_resource = Resource::new(subject);
+    let mut results_resource = Resource::new(subject.clone());
     results_resource.set_propval(urls::IS_A.into(), vec![urls::ENDPOINT].into(), store)?;
     results_resource.set_propval(urls::DESCRIPTION.into(), atomic_lib::Value::Markdown("Full text-search endpoint. You can use the keyword `AND` and `OR`, or use `\"` for advanced searches. ".into()), store)?;
     results_resource.set_propval(
@@ -147,22 +146,28 @@ pub async fn search_query(
         store,
     )?;
 
-    if return_subjects {
+    if appstate.config.opts.rdf_search {
+        // Always return all subjects, don't do authentication
         results_resource.set_propval(urls::ENDPOINT_RESULTS.into(), subjects.into(), store)?;
     } else {
+        // Default case: return full resources, do authentication
         let mut resources: Vec<Resource> = Vec::new();
+
+        let for_agent = crate::helpers::get_client_agent(req.headers(), &appstate, subject)?;
         for s in subjects {
-            // TODO: use authentication, allow for non-public search
-            let r = store.get_resource_extended(&s, true, Some(atomic_lib::authentication::PUBLIC_AGENT.into()))
-                .map_err(|e| format!("Failed to construct search results, because one of the Subjects cannot be returned. Try again with the `&subjects=true` query parameter. Error: {}", e))?;
-            resources.push(r);
+            log::info!("Subject in search result: {}", s);
+            match store.get_resource_extended(&s, true, for_agent.clone()) {
+                Ok(r) => resources.push(r),
+                Err(_e) => {
+                    log::info!("Skipping result: {} : {}", s, _e);
+                    continue;
+                }
+            }
         }
         results_resource.set_propval(urls::ENDPOINT_RESULTS.into(), resources.into(), store)?;
     }
-
-    // let json_ad = atomic_lib::serialize::resources_to_json_ad(&resources)?;
     let mut builder = HttpResponse::Ok();
-    // log::info!("Search q: {} hits: {}", &query.q, resources.len());
+    // TODO: support other serialization options
     Ok(builder.body(results_resource.to_json_ad()?))
 }
 

server/src/helpers.rs

@@ -3,7 +3,7 @@
 use actix_web::http::HeaderMap;
 use atomic_lib::authentication::AuthValues;
 
-use crate::errors::AtomicServerResult;
+use crate::{appstate::AppState, errors::AtomicServerResult};
 
 // Returns None if the string is empty.
 // Useful for parsing form inputs.
@@ -54,3 +54,22 @@ pub fn get_auth_headers(
         _missing => Err("Missing authentication headers. You need `x-atomic-public-key`, `x-atomic-signature`, `x-atomic-agent` and `x-atomic-timestamp` for authentication checks.".into()),
     }
 }
+
+/// Checks for authentication headers and returns the agent's subject if everything is well.
+/// Skips these checks in public_mode.
+pub fn get_client_agent(
+    headers: &HeaderMap,
+    appstate: &AppState,
+    requested_subject: String,
+) -> AtomicServerResult<Option<String>> {
+    if appstate.config.opts.public_mode {
+        return Ok(None);
+    }
+    // Authentication check. If the user has no headers, continue with the Public Agent.
+    let auth_header_values = get_auth_headers(headers, requested_subject)?;
+    let for_agent = atomic_lib::authentication::get_agent_from_headers_and_check(
+        auth_header_values,
+        &appstate.store,
+    )?;
+    Ok(Some(for_agent))
+}