chg: Some optimizations by using &str and Rc instead of String and Vec

Author: SinTan1729

actix/Cargo.toml

@@ -36,7 +36,7 @@ passwords = "3.1.16"
 actix-session = { version = "0.11.0", features = [ "cookie-session" ] }
 nanoid = "0.4.0"
 serde_json = "1.0.115"
-serde = { version = "1.0.197", features = [ "derive" ] }
+serde = { version = "1.0.197", features = [ "derive", "rc" ] }
 argon2 = "0.5.3"
 chrono = "0.4.41"
 tokio = "1.44.2"

actix/src/auth.rs

@@ -6,12 +6,13 @@ use actix_web::HttpRequest;
 use argon2::{password_hash::PasswordHash, Argon2, PasswordVerifier};
 use log::{debug, warn};
 use passwords::PasswordGenerator;
+use std::rc::Rc;
 use std::time::SystemTime;
 
 use crate::config::Config;
 
 // Validate API key
-pub fn validate_key(key: String, config: &Config) -> bool {
+pub fn validate_key(key: &str, config: &Config) -> bool {
     if let Some(api_key) = &config.api_key {
         // Check if API Key is hashed using Argon2. More algorithms maybe added later.
         let authorized = if config.hash_algorithm.is_some() {
@@ -22,7 +23,7 @@ pub fn validate_key(key: String, config: &Config) -> bool {
                 .is_ok()
         } else {
             // If hashing is not enabled, use the plaintext API key for matching
-            api_key == &key
+            api_key == key
         };
         if !authorized {
             warn!("Incorrect API key was provided when connecting to Chhoto URL.");
@@ -66,16 +67,16 @@ pub fn validate(session: Session, config: &Config) -> bool {
     }
 
     if let Ok(token) = session.get::<String>("chhoto-url-auth") {
-        check(token)
+        check(token.as_deref())
     } else {
         false
     }
 }
 
 // Check a token cryptographically
-fn check(token: Option<String>) -> bool {
+fn check(token: Option<&str>) -> bool {
     if let Some(token_body) = token {
-        let token_parts: Vec<&str> = token_body.split(';').collect();
+        let token_parts: Rc<[&str]> = token_body.split(';').collect();
         if token_parts.len() < 2 {
             false
         } else {

actix/src/database.rs

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: MIT
 
 use log::info;
+use rusqlite::fallible_iterator::FallibleIterator;
 use rusqlite::{Connection, Error};
 use serde::Serialize;
+use std::rc::Rc;
 
 // Struct for encoding a DB row
 #[derive(Serialize)]
@@ -15,7 +17,7 @@ pub struct DBRow {
 }
 
 // Find a single URL for /api/expand
-pub fn find_url(shortlink: String, db: &Connection) -> (Option<String>, Option<i64>, Option<i64>) {
+pub fn find_url(shortlink: &str, db: &Connection) -> (Option<String>, Option<i64>, Option<i64>) {
     // Long link, hits, expiry time
     let now = chrono::Utc::now().timestamp();
     let query = "SELECT long_url, hits, expiry_time FROM urls
@@ -37,10 +39,10 @@ pub fn find_url(shortlink: String, db: &Connection) -> (Option<String>, Option<i
 // Get all URLs in DB
 pub fn getall(
     db: &Connection,
-    page_after: Option<String>,
+    page_after: Option<&str>,
     page_no: Option<i64>,
     page_size: Option<i64>,
-) -> Vec<DBRow> {
+) -> Rc<[DBRow]> {
     let now = chrono::Utc::now().timestamp();
     let query = if page_after.is_some() {
         "SELECT short_url, long_url, hits, expiry_time FROM (
@@ -70,7 +72,7 @@ pub fn getall(
         .prepare_cached(query)
         .expect("Error preparing SQL statement for getall.");
 
-    let mut data = if let Some(pos) = page_after {
+    let data = if let Some(pos) = page_after {
         let size = page_size.unwrap_or(10);
         statement
             .query((pos, now, size))
@@ -90,26 +92,24 @@ pub fn getall(
             .expect("Error executing query for getall: no pagination.")
     };
 
-    let mut links: Vec<DBRow> = Vec::new();
-    while let Some(row) = data.next().expect("Error reading fetched rows.") {
-        let row_struct = DBRow {
-            shortlink: row
-                .get("short_url")
-                .expect("Error reading shortlink from row."),
-            longlink: row
-                .get("long_url")
-                .expect("Error reading shortlink from row."),
-            hits: row.get("hits").expect("Error reading shortlink from row."),
-            expiry_time: row.get("expiry_time").unwrap_or_default(),
-        };
-        links.push(row_struct);
-    }
+    let links: Rc<[DBRow]> = data
+        .map(|row| {
+            let row_struct = DBRow {
+                shortlink: row.get("short_url")?,
+                longlink: row.get("long_url")?,
+                hits: row.get("hits")?,
+                expiry_time: row.get("expiry_time").unwrap_or_default(),
+            };
+            Ok(row_struct)
+        })
+        .collect()
+        .expect("Error procecssing fetched row.");
 
     links
 }
 
 // Add a hit when site is visited during link resolution
-pub fn find_and_add_hit(shortlink: String, db: &Connection) -> Option<String> {
+pub fn find_and_add_hit(shortlink: &str, db: &Connection) -> Option<String> {
     let now = chrono::Utc::now().timestamp();
     let mut statement = db
         .prepare_cached(
@@ -208,7 +208,7 @@ pub fn cleanup(db: &Connection) {
 }
 
 // Delete an existing link
-pub fn delete_link(shortlink: String, db: &Connection) -> bool {
+pub fn delete_link(shortlink: &str, db: &Connection) -> bool {
     let mut statement = db
         .prepare_cached("DELETE FROM urls WHERE short_url = ?1")
         .expect("Error preparing SQL statement for delete_link.");
@@ -219,7 +219,7 @@ pub fn delete_link(shortlink: String, db: &Connection) -> bool {
     }
 }
 
-pub fn open_db(path: String, use_wal_mode: bool) -> Connection {
+pub fn open_db(path: &str, use_wal_mode: bool) -> Connection {
     // Set current user_version. Should be incremented on change of schema.
     let user_version = 1;
 

actix/src/main.rs

@@ -79,26 +79,22 @@ async fn main() -> Result<()> {
     );
 
     // Do periodic cleanup
-    let db_location_clone = conf.db_location.clone();
+    let db_location = conf.db_location.clone();
     // Create backups if WAL mode is being used
     if conf.use_wal_mode {
         info!("Creating database backups.");
-        if fs::exists(format!("{db_location_clone}.bak1")).ok() == Some(true) {
-            fs::rename(
-                format!("{db_location_clone}.bak1"),
-                format!("{db_location_clone}.bak2"),
-            )
-            .expect("Error creating backups.");
-        }
-        if fs::exists(&db_location_clone).ok() == Some(true) {
-            fs::copy(&db_location_clone, format!("{db_location_clone}.bak1"))
+        if fs::exists(format!("{db_location}.bak1")).ok() == Some(true) {
+            fs::rename(format!("{db_location}.bak1"), format!("{db_location}.bak2"))
                 .expect("Error creating backups.");
         }
+        if fs::exists(&db_location).ok() == Some(true) {
+            fs::copy(&db_location, format!("{db_location}.bak1")).expect("Error creating backups.");
+        }
     }
 
     info!("Starting cleanup service, will run once every hour.");
     spawn(async move {
-        let db = database::open_db(db_location_clone, conf.use_wal_mode);
+        let db = database::open_db(&db_location, conf.use_wal_mode);
         let mut interval = time::interval(time::Duration::from_secs(3600));
         loop {
             interval.tick().await;
@@ -123,7 +119,7 @@ async fn main() -> Result<()> {
             )
             // Maintain a single instance of database throughout
             .app_data(web::Data::new(AppState {
-                db: database::open_db(conf_clone.db_location.clone(), conf.use_wal_mode),
+                db: database::open_db(&conf.db_location, conf.use_wal_mode),
                 config: conf_clone.clone(),
             }))
             .wrap(if let Some(header) = &conf.cache_control_header {

actix/src/services.rs

@@ -85,7 +85,7 @@ pub async fn add_link(
     let result = utils::is_api_ok(http, config);
     // If success, add new link
     if result.success {
-        let (success, reply, expiry_time) = utils::add_link(req, &data.db, config, false);
+        let (success, reply, expiry_time) = utils::add_link(&req, &data.db, config, false);
         if success {
             let site_url = config.site_url.clone();
             let shorturl = if let Some(url) = site_url {
@@ -119,9 +119,9 @@ pub async fn add_link(
     // If password authentication or public mode is used - keeps backwards compatibility
     } else {
         let (success, reply, _) = if auth::validate(session, config) {
-            utils::add_link(req, &data.db, config, false)
+            utils::add_link(&req, &data.db, config, false)
         } else if config.public_mode {
-            utils::add_link(req, &data.db, config, true)
+            utils::add_link(&req, &data.db, config, true)
         } else {
             return HttpResponse::Unauthorized().body("Not logged in!");
         };
@@ -162,7 +162,7 @@ pub async fn getall(
 pub async fn expand(req: String, data: web::Data<AppState>, http: HttpRequest) -> HttpResponse {
     let result = utils::is_api_ok(http, &data.config);
     if result.success {
-        let (longurl, hits, expiry_time) = database::find_url(req, &data.db);
+        let (longurl, hits, expiry_time) = database::find_url(&req, &data.db);
         if let Some(longlink) = longurl {
             let body = LinkInfo {
                 success: true,
@@ -197,7 +197,7 @@ pub async fn edit_link(
     let config = &data.config;
     let result = utils::is_api_ok(http, config);
     if result.success || validate(session, config) {
-        if let Some((server_error, error_msg)) = utils::edit_link(req, &data.db, config) {
+        if let Some((server_error, error_msg)) = utils::edit_link(&req, &data.db, config) {
             let body = Response {
                 success: false,
                 error: true,
@@ -300,7 +300,7 @@ pub async fn link_handler(
     shortlink: web::Path<String>,
     data: web::Data<AppState>,
 ) -> impl Responder {
-    let shortlink_str = shortlink.to_string();
+    let shortlink_str = shortlink.as_str();
     if let Some(longlink) = database::find_and_add_hit(shortlink_str, &data.db) {
         if data.config.use_temp_redirect {
             Either::Left(Redirect::to(longlink))
@@ -406,11 +406,7 @@ pub async fn delete_link(
     let result = utils::is_api_ok(http, config);
     // If success, delete shortlink
     if result.success {
-        if utils::delete_link(
-            shortlink.to_string(),
-            &data.db,
-            data.config.allow_capital_letters,
-        ) {
+        if utils::delete_link(&shortlink, &data.db, data.config.allow_capital_letters) {
             let response = Response {
                 success: true,
                 error: false,
@@ -429,11 +425,7 @@ pub async fn delete_link(
         HttpResponse::Unauthorized().json(result)
     // If "pass" is true - keeps backwards compatibility
     } else if auth::validate(session, config) {
-        if utils::delete_link(
-            shortlink.to_string(),
-            &data.db,
-            data.config.allow_capital_letters,
-        ) {
+        if utils::delete_link(&shortlink, &data.db, data.config.allow_capital_letters) {
             HttpResponse::Ok().body(format!("Deleted {shortlink}"))
         } else {
             HttpResponse::NotFound().body("Not found!")

actix/src/tests.rs

@@ -4,6 +4,7 @@ use actix_web::test;
 use actix_web::{body::to_bytes, dev::ServiceResponse, web::Bytes, App, Error};
 use regex::Regex;
 use serde::Deserialize;
+use std::rc::Rc;
 use std::{fmt::Display, fs, thread::sleep, time::Duration};
 
 use super::*;
@@ -77,7 +78,7 @@ async fn create_app(
         App::new()
             .app_data(web::Data::new(AppState {
                 db: database::open_db(
-                    format!("/tmp/chhoto-url-test-{test}.sqlite"),
+                    format!("/tmp/chhoto-url-test-{test}.sqlite").as_str(),
                     conf.use_wal_mode,
                 ),
                 config: conf.clone(),
@@ -295,7 +296,7 @@ async fn data_fetching_all() {
     let resp = test::call_service(&app, req).await;
     assert!(resp.status().is_success());
     let body = to_bytes(resp.into_body()).await.unwrap();
-    let reply_chunks: Vec<URLData> = serde_json::from_str(body.as_str()).unwrap();
+    let reply_chunks: Rc<[URLData]> = serde_json::from_str(body.as_str()).unwrap();
     assert_eq!(reply_chunks.len(), 2);
     assert_eq!(reply_chunks[0].shortlink, "test1");
     assert_eq!(reply_chunks[1].shortlink, "test3");
@@ -314,7 +315,7 @@ async fn data_fetching_all() {
     let resp = test::call_service(&app, req).await;
     assert!(resp.status().is_success());
     let body = to_bytes(resp.into_body()).await.unwrap();
-    let reply_chunks: Vec<URLData> = serde_json::from_str(body.as_str()).unwrap();
+    let reply_chunks: Rc<[URLData]> = serde_json::from_str(body.as_str()).unwrap();
     assert_eq!(reply_chunks.len(), 1);
     assert_eq!(reply_chunks[0].shortlink, "test1");
 
@@ -326,7 +327,7 @@ async fn data_fetching_all() {
     let resp = test::call_service(&app, req).await;
     assert!(resp.status().is_success());
     let body = to_bytes(resp.into_body()).await.unwrap();
-    let reply_chunks: Vec<URLData> = serde_json::from_str(body.as_str()).unwrap();
+    let reply_chunks: Rc<[URLData]> = serde_json::from_str(body.as_str()).unwrap();
     assert_eq!(reply_chunks.len(), 1);
     assert_eq!(reply_chunks[0].shortlink, "test1");
 

actix/src/utils.rs

@@ -44,7 +44,7 @@ pub fn is_api_ok(http: HttpRequest, config: &Config) -> Response {
         // If the header exists
         if let Some(header) = auth::api_header(&http) {
             // If the header is correct
-            if auth::validate_key(header.to_string(), config) {
+            if auth::validate_key(header, config) {
                 Response {
                     success: true,
                     error: false,
@@ -105,20 +105,20 @@ pub fn getall(db: &Connection, params: GetReqParams) -> String {
     let page_after = params.page_after.filter(|s| !s.is_empty());
     let page_no = params.page_no.filter(|&n| n > 0);
     let page_size = params.page_size.filter(|&n| n > 0);
-    let links = database::getall(db, page_after, page_no, page_size);
+    let links = database::getall(db, page_after.as_deref(), page_no, page_size);
     serde_json::to_string(&links).expect("Failure during creation of json from db.")
 }
 
 // Make checks and then request the DB to add a new URL entry
 pub fn add_link(
-    req: String,
+    req: &str,
     db: &Connection,
     config: &Config,
     using_public_mode: bool,
 ) -> (bool, String, i64) {
     // Success status, response string, expiry time
     let mut chunks: NewURLRequest;
-    if let Ok(json) = serde_json::from_str(&req) {
+    if let Ok(json) = serde_json::from_str(req) {
         chunks = json;
     } else {
         return (false, String::from("Invalid request!"), 0);
@@ -173,13 +173,13 @@ pub fn add_link(
 }
 
 // Make checks and then request the DB to edit an URL entry
-pub fn edit_link(req: String, db: &Connection, config: &Config) -> Option<(bool, String)> {
+pub fn edit_link(req: &str, db: &Connection, config: &Config) -> Option<(bool, String)> {
     // None means success
     // The boolean is true when it's a server error and false when it's a client error
     // The string is the error message
 
     let chunks: EditURLRequest;
-    if let Ok(json) = serde_json::from_str(&req) {
+    if let Ok(json) = serde_json::from_str(req) {
         chunks = json;
     } else {
         return Some((false, String::from("Malformed request!")));
@@ -201,16 +201,16 @@ pub fn edit_link(req: String, db: &Connection, config: &Config) -> Option<(bool,
     }
 }
 // Check if link, and request DB to delete it if exists
-pub fn delete_link(shortlink: String, db: &Connection, allow_capital_letters: bool) -> bool {
-    if validate_link(shortlink.as_str(), allow_capital_letters) {
+pub fn delete_link(shortlink: &str, db: &Connection, allow_capital_letters: bool) -> bool {
+    if validate_link(shortlink, allow_capital_letters) {
         database::delete_link(shortlink, db)
     } else {
         false
     }
 }
 
 // Generate a random link using either adjective-name pair (default) of a slug or a-z, 0-9
-fn gen_link(style: &String, len: usize, allow_capital_letters: bool) -> String {
+fn gen_link(style: &str, len: usize, allow_capital_letters: bool) -> String {
     #[rustfmt::skip]
     static ADJECTIVES: [&str; 108] = ["admiring", "adoring", "affectionate", "agitated", "amazing", "angry", "awesome", "beautiful", 
 		"blissful", "bold", "boring", "brave", "busy", "charming", "clever", "compassionate", "competent", "condescending", "confident", "cool",