überall async entfernt, lauffähiger Zustand

Cargo.toml

@@ -5,12 +5,11 @@ edition = "2021"
 
 [dependencies]
 pandoc = "0.8"
-tokio = { version = "1", features = ["full"] }
 chrono = "0.4.38"
 regex = "1.10.5"
 futures = "0.3.30"
 headers = "0.4.0"
-reqwest = "0.12.5"
+reqwest = {version = "0.12.5", features = ["blocking"]}
 lettre = "0.11.7"
 rand = "0.9.0-alpha.1"
 rusqlite = "0.31.0"

src/hedgedoc.rs

@@ -1,4 +1,5 @@
-use reqwest::{Client,Response};
+use reqwest::blocking::Response;
+use reqwest::blocking::Client;
 use std::error::Error;
 
 // TODO: implement dry-run logic
@@ -21,28 +22,28 @@ impl HedgeDoc {
         format!( "{}/{}/{}", self.server_url, pad_name, verb )
     }
 
-    async fn do_request( &self, url : &str ) -> Result<Response, Box<dyn Error>> {
+    fn do_request(&self, url : &str ) -> Result<Response, Box<dyn Error>> {
-        Ok(self.client.get( url ).send().await?)
+        Ok(self.client.get( url ).send().unwrap())
     }
 
     fn get_id_from_response( &self, res : Response ) -> String {
         res.url().to_string().trim_start_matches( &format!( "{}/", self.server_url ) ).to_string()
     }
 
-    pub async fn download( &self, pad_name: &str ) -> Result<String, Box<dyn Error>> {
+    pub fn download( &self, pad_name: &str ) -> Result<String, Box<dyn Error>> {
-        Ok(self.do_request( &self.format_action(pad_name, "download") ).await?.text().await?)
+        Ok(self.do_request( &self.format_action(pad_name, "download"))?.text()?)
     }
 
-    pub async fn create_pad( &self ) -> Result<String, Box<dyn Error>> {
+    pub fn create_pad( &self ) -> Result<String, Box<dyn Error>> {
-        let res = self.do_request( &format!( "{}/new", self.server_url ) ).await?;
+        let res = self.do_request( &format!( "{}/new", self.server_url ) ).unwrap();
         if res.status().is_success() {
             Ok(self.get_id_from_response(res))
         } else {
-            Err( format!("Failed to create pad {}\n{}", res.status(), res.text().await?).into() )
+            Err( format!("Failed to create pad {}", res.status()).into() )
         }
     }
 
-    pub async fn import_note( &self, id: Option<&str>, content: String ) -> Result<String, Box<dyn Error>> {
+    pub fn import_note( &self, id: Option<&str>, content: String ) -> Result<String, Box<dyn Error>> {
         let url = match id {
             Some(id) => self.format_url( &format!( "new/{id}" ) ),
             None => self.format_url("new"),
@@ -51,13 +52,12 @@ impl HedgeDoc {
         let res = self.client.post(&url)
             .header( "Content-Type", "text/markdown" )
             .body(content)
-            .send()
+            .send()?;
-            .await?;
 
         if res.status().is_success() {
             Ok(self.get_id_from_response(res))
         } else {
-            Err( format!("Failed to import note: {}\n{}", res.status(), res.text().await?).into() )
+            Err( format!("Failed to import note: {}", res.status()).into() )
         }
     }
 }

src/main.rs

@@ -50,7 +50,6 @@ use uuid::Uuid;
 use lettre::{Message, SmtpTransport, Transport};
 use lettre::message::{header, SinglePart};
 use lettre::transport::smtp::authentication::Credentials;
-use reqwest;
 
 const FALLBACK_TEMPLATE: &str = variables_and_settings::FALLBACK_TEMPLATE;
 
@@ -96,8 +95,7 @@ fn parse_args() -> Args {
 
 /* ***** Main ***** */
 
-#[tokio::main]
+fn main() -> Result<(), Box<dyn Error>> {
-async fn main() -> Result<(), Box<dyn Error>> {
     // set up config file access
     let args = parse_args();
     let config_file = args.config_file.as_str();
@@ -164,7 +162,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let top_anzahl: i32 = 0; // Muss noch gecodet werden
     let yesterday_was_plenum = true; // Das ist nur zu Testzwecken, kommt noch weg
-    let pad_content = hedgedoc.download(&current_pad_id).await.expect("Fehler beim Download des Pads!");
+    let pad_content = hedgedoc.download(&current_pad_id).expect("Fehler beim Download des Pads!");
     let pad_content_without_top_instructions = try_to_remove_top_instructions(pad_content);
     println!("Pad-content geladen!");
     let current_pad_link = hedgedoc.format_url(&current_pad_id);
@@ -181,7 +179,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
         if number_of_tops(&pad_content_without_top_instructions) != 0 {
             // Mail an alle senden, findet statt
-            let betreff = format!("Morgen ist Plenum!"); // ADJ_TIMEYWIMEY
+            let betreff = "Morgen ist Plenum!".to_string(); // ADJ_TIMEYWIMEY
             let message: String = format!(r#"{email_greeting}
 
 Es gibt Themen, deshalb wird das morgige Plenum statt finden. Anbei das Plenumspad:
@@ -198,17 +196,17 @@ Bis morgen, 20 Uhr!
             message_id = Some(mail_versenden(&config, betreff, message).expect("Plenum findet statt. Mail wurde versucht zu senden, konnte aber nicht gesendet werden!"))
         } else {
             // Mail an alle senden und absagen
-            let betreff = format!("Plenum am {nächster_plenumtermin} fällt mangels Themen aus");
+            let betreff = format!("Plenum am {} fällt mangels Themen aus", nächster_plenumtermin);
             let message: String = format!(r#"{email_greeting}
 
 Es gibt keine Themen, deshalb wird das morgige Plenum leider nicht statt finden.
 
-Hier ist der Link zum Pad vom nächsten Plenum, das am {nächster_plenumtermin} statt finden wird:
+Hier ist der Link zum Pad vom nächsten Plenum, das am {} statt finden wird:
   {future_pad_link}
 
 Bis zum nächsten Plenum.
 
-{email_signature}"#);
+{email_signature}"#, nächster_plenumtermin);
             println!("---E-Mail:---\n{}\n-----------", message);
             // XXX option x expect
             message_id = Some(mail_versenden(&config, betreff, message).expect("Plenum wird abgesagt. Mail wurde versucht zu senden, konnte aber nicht gesendet werden!"))
@@ -217,7 +215,7 @@ Bis zum nächsten Plenum.
         println!("In 3 Tagen ist Plenum, deshalb wird eine Erinnerung raus geschickt!");
         if number_of_tops(&pad_content_without_top_instructions) == 0 {
             // Mail an alle senden und sagen, dass es noch keine Themen gibt
-            let betreff = format!("Plenum vom {nächster_plenumtermin}: Bisher noch keine Themen");
+            let betreff = format!("Plenum vom {}: Bisher noch keine Themen", nächster_plenumtermin);
             let message: String = format!(r#"{email_greeting}
 
 Es sind bisher leider keine Themen zusammengekommen.  Wenn es bis Sonntag Abend keine Themen gibt, wird das Plenum voraussichtlich nicht statt finden.
@@ -232,7 +230,7 @@ Hier ist der Link zum Pad, wo ihr noch Themen eintragen könnt:
         }
     } else if yesterday_was_plenum {
         // This logic breaks on 02/2034, but on every other month it works
-        let old_pad_content = hedgedoc.download(&current_pad_id).await.expect("Fehler beim Download des Pads!");
+        let old_pad_content = hedgedoc.download(&current_pad_id).expect("Fehler beim Hedgedoc-Pad-Download!");
         // MUSS WIEDER REIN NACH DEM TESTEN: generate_new_pad_for_following_date(übernächster_plenumtermin, überübernächster_plenumtermin, &config).await.expect("Fehler! Plenumspad konnte nicht generiert werden!");
         println!("DATENBANK: aktuelles-plenumspad: {:?} und zukünftiges plenumspad: {:?}", &config.get("hedgedoc-last-id"), &config.get("hedgedoc-next-id"));
 
@@ -355,25 +353,22 @@ fn mail_versenden(config: &KV, betreff: String, inhalt: String) -> std::result::
     }
 }
 
-async fn generate_new_pad_for_following_date(config : KV, hedgedoc : HedgeDoc, übernächster_plenumtermin: &String, überübernächster_plenumtermin: &String, kv: &KV) -> Result<(), Box<dyn Error>> {
+fn generate_new_pad_for_following_date(config : KV, hedgedoc : HedgeDoc, übernächster_plenumtermin: &String, überübernächster_plenumtermin: &String, kv: &KV) -> Result<(), Box<dyn Error>> {
 
-    match hedgedoc.create_pad( ).await {
+    match hedgedoc.create_pad( ) {
         Err(e) => println!("Failed to create pad: {}", e),
         Ok(pad_id) => {
             println!("Pad created successfully with ID: {}", pad_id);
 
             // Get the most recent plenum template and replace the placeholders:
-            let template_content = match config.get("hedgedoc-template-name") {
+            let template_content: String = match config.get("hedgedoc-template-name") {
-                Ok(str) => match hedgedoc.download(&str).await {
+                Ok(content) => hedgedoc.download(&content.clone()).unwrap_or_else(|_| FALLBACK_TEMPLATE.to_string()),
-                    Ok(content) => content,
-                    Err(_) => FALLBACK_TEMPLATE.to_string(),
-                }
                 Err(_) => FALLBACK_TEMPLATE.to_string(),
             };
             // XXX you don't just use the template as-is…
             let template_modified: String = replace_placeholders(&template_content, übernächster_plenumtermin, überübernächster_plenumtermin).unwrap_or_else(|error |template_content); // Try regex, if not successful use without regex
 
-            match hedgedoc.import_note( Some(&pad_id), template_modified ).await {
+            match hedgedoc.import_note( Some(&pad_id), template_modified ) {
                 Ok(_) => {
                     println!("Pad updated successfully with template content.");
                     rotate (&pad_id, kv);