From adbbd52b3eaf491da14c1802abee26df999d6929 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?=
 <96421894+Tahinli@users.noreply.github.com>
Date: Mon, 11 Mar 2024 03:34:52 +0300
Subject: [PATCH] feat: :sparkles: always control server status

---
 front/Cargo.toml  |  1 +
 front/src/main.rs | 99 ++++++++++++++++++++++++++++++++++-------------
 2 files changed, 74 insertions(+), 26 deletions(-)

diff --git a/front/Cargo.toml b/front/Cargo.toml
index 80c79ad..890291c 100644
--- a/front/Cargo.toml
+++ b/front/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+async-std = "1.12.0"
 dioxus = { version = "0.5.0-alpha.0", features = ["web"] }
 log = "0.4.21"
 reqwest = { version = "0.11.24", features = ["json"] }
diff --git a/front/src/main.rs b/front/src/main.rs
index 0e2e411..cab0a88 100644
--- a/front/src/main.rs
+++ b/front/src/main.rs
@@ -1,7 +1,15 @@
+use std::time::Duration;
+use async_std::task;
 use dioxus::prelude::*;
 use serde::Deserialize;
 
 const SERVER_ADDRESS: &str = "https://localhost:2323";
+
+static SERVER_STATUS:GlobalSignal<ServerStatus> = Signal::global(move || ServerStatus {status:"Alive".to_string(),});
+static SERVER_STATUS_WATCHDOG:GlobalSignal<bool> = Signal::global(move || false);
+static SERVER_STATUS_LOOSING:GlobalSignal<bool> = Signal::global(move || false);
+static SERVER_STATUS_IS_DEAD:GlobalSignal<bool> = Signal::global(move || false);
+
 #[derive(Debug, Clone, PartialEq, Deserialize)]
 struct ServerStatus{
     status: String,
@@ -17,8 +25,26 @@ fn main() {
     launch(app);
 }
 
-async fn server_status_check() ->Result<ServerStatus, reqwest::Error> {
-    Ok(reqwest::get(SERVER_ADDRESS).await.unwrap().json::<ServerStatus>().await.unwrap())
+async fn server_status_check() ->ServerStatus {
+    match reqwest::get(SERVER_ADDRESS).await {
+        Ok(response) => {
+            *SERVER_STATUS_WATCHDOG.write() = false;
+            match response.json::<ServerStatus>().await {
+                Ok(server_status) => {
+                    *SERVER_STATUS_LOOSING.write() = false;
+                    server_status
+                }
+                Err(err_val) => {
+                    *SERVER_STATUS_LOOSING.write() = true;
+                    ServerStatus{status:err_val.to_string(),}
+                }
+            }
+        }
+        Err(err_val) => {
+            *SERVER_STATUS_LOOSING.write() = true;
+            ServerStatus{status:err_val.to_string(),}
+        }
+    }
 }
 async fn coin_status_check() -> Result<CoinStatus, reqwest::Error> {
     Ok(reqwest::get(format!("{}{}", SERVER_ADDRESS, "/coin")).await.unwrap().json::<CoinStatus>().await.unwrap())
@@ -46,34 +72,57 @@ fn page_base() ->Element {
         }
     }
 }
-
 fn server_status_renderer() -> Element {
-    let server_status = use_resource(move || server_status_check());
-    match &*server_status.value().read() {
-        Some(Ok(server_status)) => {
-            rsx! {
-                h5 {
-                    ShowServerStatus { server_status: server_status.clone() }
+    let server_check_time = 1_u64;
+    let _server_status_task:Coroutine<()> = use_coroutine(|_| async move {
+        loop {
+            task::sleep(Duration::from_secs(server_check_time)).await;
+            *SERVER_STATUS_WATCHDOG.write() = true;
+            *SERVER_STATUS.write() = server_status_check().await;
+            /*match server_status_check().await {
+                Ok(status) => {
+                    server_status_watchdog.set(false);
+                    server_status.set(status);
                 }
-            }
+                Err(err_val) => {
+                    server_status.set(ServerStatus {status:err_val.to_string(),});
+                }
+            }*/
             
-        }
-        Some(Err(err_val)) => {
-            rsx! {
-                h5 {
-                    "Server Status: "
-                    { err_val.to_string() }
+        };
+    });
+    let _server_status_watchdog_timer:Coroutine<()> = use_coroutine(|_| async move {
+            let mut is_loosing_counter = 0_i8;
+            loop {  
+                task::sleep(Duration::from_secs(2*server_check_time+1)).await;
+                if !SERVER_STATUS_WATCHDOG() {
+                    *SERVER_STATUS_LOOSING.write() = false;
                 }
-            }
-        }
-        None => {
-            rsx! {
-                h5 {
-                    "Server Status: Dead"
+                if SERVER_STATUS_WATCHDOG() {
+                    for _i in 0..5 {
+                        task::sleep(Duration::from_secs(1)).await;
+                        if SERVER_STATUS_WATCHDOG() {
+                            is_loosing_counter += 1;
+                        }
+                    }
+                    
                 }
-            }
+                if is_loosing_counter > 4 {
+                    *SERVER_STATUS_LOOSING.write() = true;
+                }
+                is_loosing_counter = 0;
+        }
+    });
+    rsx! {
+        if SERVER_STATUS_LOOSING() && SERVER_STATUS_WATCHDOG() {
+            {*SERVER_STATUS_IS_DEAD.write() = true}
+            ShowServerStatus {server_status:ServerStatus{status:"Dead".to_string(),}}
+        }
+        else {
+            ShowServerStatus {server_status:SERVER_STATUS()}        
         }
     }
+    
 }
 fn coin_status_renderer() -> Element {
     let is_loading = use_signal(|| false);
@@ -89,15 +138,13 @@ fn coin_status_renderer() -> Element {
                         is_loading.set(false);
                         coin_result.set(coin_status);
                     }
-                    Err(err_val) => {
+                    Err(_) => {
                         is_loading.set(false);
-                        log::info!("{}", err_val);
                     }
                 }
             }
         });
     };
-    log::info!("{}", is_loading);
     rsx! {
         div {
             button {