Update error log base path

Error logs were been moved to /data some time ago. This change makes
them accessible again.

2 files changed, 66 insertions, 12 deletions

diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 4be2da2..a0c9a33 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -1290,6 +1290,55 @@ async fn handle_log_read_response(response: Response) -> String {
 }
 
 #[tauri::command]
+async fn errlog_read(logfile: String, state: State<'_, Mutex<Session>>) -> Result<String, ()> {
+    let (client, instance) = {
+        let state = state.lock().unwrap();
+        (state.client.clone(), state.instance.clone())
+    };
+    let instance = match instance {
+        Some(instance) => instance,
+        None => {
+            return Ok(String::from(
+                "Keine Instanz ausgewählt, bitte melden Sie sich neu an!",
+            ))
+        }
+    };
+
+    let response = client
+        .get(instance.url.join("/data/read").unwrap())
+        .query(&[("path", format!("/data/{}", logfile))])
+        .basic_auth("rustkrazy", Some(&instance.password))
+        .send();
+
+    Ok(match response.await {
+        Ok(response) => handle_errlog_read_response(response).await,
+        Err(e) => format!("Abfrage fehlgeschlagen: {}", e),
+    })
+}
+
+async fn handle_errlog_read_response(response: Response) -> String {
+    let status = response.status();
+    if status.is_success() {
+        match response.text().await {
+            Ok(logs) => logs,
+            Err(e) => format!("Keinen Text vom Server erhalten. Fehler: {}", e),
+        }
+    } else if status == StatusCode::UNAUTHORIZED {
+        String::from("Ungültiges Verwaltungspasswort, bitte melden Sie sich neu an!")
+    } else if status == StatusCode::NOT_FOUND {
+        String::from(
+            "Protokolldatei existiert nicht, möglicherweise ist der Dienst noch nicht gestartet",
+        )
+    } else if status.is_client_error() {
+        format!("Clientseitiger Fehler: {}", status)
+    } else if status.is_server_error() {
+        format!("Serverseitiger Fehler: {}", status)
+    } else {
+        format!("Unerwarteter Statuscode: {}", status)
+    }
+}
+
+#[tauri::command]
 async fn vpnclients(state: State<'_, Mutex<Session>>) -> Result<VpnClients, ()> {
     let (client, instance) = {
         let state = state.lock().unwrap();
@@ -1639,6 +1688,7 @@ fn main() {
             reboot,
             shutdown,
             log_read,
+            errlog_read,
             vpnclients,
             vpndel,
             vpnadd
diff --git a/src/log.js b/src/log.js
index b771ed9..f651225 100644
--- a/src/log.js
+++ b/src/log.js
@@ -31,31 +31,35 @@ async function logRead(logfile) {
   return await invoke("log_read", { logfile: logfile });
 }
 
+async function errRead(logfile) {
+  return await invoke("errlog_read", { logfile: logfile });
+}
+
 async function loadNonDns() {
   logAdmindStdoutEl.value = await logRead("rustkrazy_admind.log");
-  logAdmindStderrEl.value = await logRead("rustkrazy_admind.err");
+  logAdmindStderrEl.value = await errRead("rustkrazy_admind.err");
   logNetlinkdStdoutEl.value = await logRead("rsdsl_netlinkd.log");
-  logNetlinkdStderrEl.value = await logRead("rsdsl_netlinkd.err");
+  logNetlinkdStderrEl.value = await errRead("rsdsl_netlinkd.err");
   logNetfilterdStdoutEl.value = await logRead("rsdsl_netfilterd.log");
-  logNetfilterdStderrEl.value = await logRead("rsdsl_netfilterd.err");
+  logNetfilterdStderrEl.value = await errRead("rsdsl_netfilterd.err");
   logDhcp4dStdoutEl.value = await logRead("rsdsl_dhcp4d.log");
-  logDhcp4dStderrEl.value = await logRead("rsdsl_dhcp4d.err");
+  logDhcp4dStderrEl.value = await errRead("rsdsl_dhcp4d.err");
   logPppoe3StdoutEl.value = await logRead("rsdsl_pppoe3.log");
-  logPppoe3StderrEl.value = await logRead("rsdsl_pppoe3.err");
+  logPppoe3StderrEl.value = await errRead("rsdsl_pppoe3.err");
   logDhcp6StdoutEl.value = await logRead("rsdsl_dhcp6.log");
-  logDhcp6StderrEl.value = await logRead("rsdsl_dhcp6.err");
+  logDhcp6StderrEl.value = await errRead("rsdsl_dhcp6.err");
   logDsliteStdoutEl.value = await logRead("rsdsl_dslite.log");
-  logDsliteStderrEl.value = await logRead("rsdsl_dslite.err");
+  logDsliteStderrEl.value = await errRead("rsdsl_dslite.err");
   logNtpStdoutEl.value = await logRead("rsdsl_ntp.log");
-  logNtpStderrEl.value = await logRead("rsdsl_ntp.err");
+  logNtpStderrEl.value = await errRead("rsdsl_ntp.err");
   logRadvdStdoutEl.value = await logRead("rsdsl_radvd.log");
-  logRadvdStderrEl.value = await logRead("rsdsl_radvd.err");
+  logRadvdStderrEl.value = await errRead("rsdsl_radvd.err");
   logNetdumpdStdoutEl.value = await logRead("rsdsl_netdumpd.log");
-  logNetdumpdStderrEl.value = await logRead("rsdsl_netdumpd.err");
+  logNetdumpdStderrEl.value = await errRead("rsdsl_netdumpd.err");
   logDyndnsStdoutEl.value = await logRead("dyndns.log");
-  logDyndnsStderrEl.value = await logRead("dyndns.err");
+  logDyndnsStderrEl.value = await errRead("dyndns.err");
   logWgdStdoutEl.value = await logRead("rsdsl_wgd.log");
-  logWgdStderrEl.value = await logRead("rsdsl_wgd.err");
+  logWgdStderrEl.value = await errRead("rsdsl_wgd.err");
 
   logAdmindStdoutEl.scrollTop = logAdmindStdoutEl.scrollHeight;
   logAdmindStderrEl.scrollTop = logAdmindStderrEl.scrollHeight;