rewrite server querying logic for efficiency

Author: AmyrAhmady

src-tauri/src/main.rs

@@ -18,10 +18,10 @@ use gumdrop::Options;
 use injector::run_samp;
 use log::{error, info, LevelFilter};
 // use std::io::Read;
-use tauri::Manager;
-use tauri::PhysicalSize;
 use std::fs;
 use tauri::api::path::app_data_dir;
+use tauri::Manager;
+use tauri::PhysicalSize;
 
 #[path = "deeplink/lib.rs"]
 #[cfg(target_os = "windows")]
@@ -106,9 +106,9 @@ Options:
 
             if args.host.is_some() && args.name.is_some() && args.port.is_some() {
                 if args.gamepath.is_some() && args.gamepath.as_ref().unwrap().len() > 0 {
-                    let password : String = if args.password.is_some() { 
+                    let password: String = if args.password.is_some() {
                         args.password.unwrap()
-                    } else { 
+                    } else {
                         "".to_string()
                     };
                     let _ = run_samp(
@@ -209,7 +209,8 @@ Options:
             commands::get_gtasa_path_from_samp,
             commands::get_nickname_from_samp,
             commands::get_samp_favorite_list,
-            commands::rerun_as_admin
+            commands::rerun_as_admin,
+            query::query_server
         ])
         .run(tauri::generate_context!())
     {

src-tauri/src/query.rs

@@ -1,15 +1,23 @@
 use actix_web::web::Buf;
 use byteorder::{LittleEndian, ReadBytesExt};
+use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use std::io::{Cursor, Read};
+use std::collections::HashMap;
+use std::io::{Cursor, Error, ErrorKind, Read};
+use std::sync::Mutex;
+use std::time::{SystemTime, UNIX_EPOCH};
 use std::{net::Ipv4Addr, time::Duration};
 use tokio::net::{lookup_host, UdpSocket};
 use tokio::time::timeout_at;
 use tokio::time::Instant;
 
 use crate::helpers;
 
+static OMP_EXTRA_INFO_LAST_UPDATE_LIST: Lazy<Mutex<HashMap<String, u64>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+const OMP_EXTRA_INFO_UPDATE_COOLDOWN_SECS: u64 = 3;
+
 pub struct Query {
     address: Ipv4Addr,
     port: i32,
@@ -40,6 +48,21 @@ pub struct ExtraInfoPacket {
     pub logo_url: String,
 }
 
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct ServerQueryResponse {
+    pub info: Option<String>,
+    pub extra_info: Option<String>,
+    pub players: Option<String>,
+    pub rules: Option<String>,
+    pub ping: Option<u32>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct ErrorResponse {
+    pub info: String,
+    pub error: bool,
+}
+
 impl Query {
     pub async fn new(addr: &str, port: i32) -> Result<Self, std::io::Error> {
         let regex = Regex::new(r"^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$").unwrap();
@@ -119,7 +142,7 @@ impl Query {
         };
 
         if amt == 0 {
-            return Ok(String::from("no_data"));
+            return Err(Error::new(ErrorKind::Other, String::from("no_data")));
         }
 
         let query_type = buf[10] as char;
@@ -135,7 +158,7 @@ impl Query {
         } else if query_type == 'p' {
             Ok(String::from("pong"))
         } else {
-            Ok(String::from("no_data"))
+            Err(Error::new(ErrorKind::Other, String::from("no_data")))
         }
     }
 
@@ -238,3 +261,118 @@ impl Query {
         Ok(serde_json::to_string(&rules).unwrap())
     }
 }
+
+#[tauri::command]
+pub async fn query_server(
+    ip: &str,
+    port: i32,
+    info: bool,
+    extra_info: bool,
+    players: bool,
+    rules: bool,
+    ping: bool,
+) -> Result<String, String> {
+    match Query::new(ip, port).await {
+        Ok(q) => {
+            let mut result = ServerQueryResponse {
+                info: None,
+                extra_info: None,
+                players: None,
+                rules: None,
+                ping: None,
+            };
+
+            if info {
+                let _ = q.send('i').await;
+                result.info = Some(match q.recv().await {
+                    Ok(p) => format!("{}", p),
+                    Err(e) => {
+                        let mut error_details = ErrorResponse::default();
+                        error_details.error = true;
+                        error_details.info = e.to_string();
+                        serde_json::to_string(&error_details).unwrap()
+                    }
+                });
+            }
+
+            if players {
+                let _ = q.send('c').await;
+                result.players = Some(match q.recv().await {
+                    Ok(p) => format!("{}", p),
+                    Err(e) => {
+                        let mut error_details = ErrorResponse::default();
+                        error_details.error = true;
+                        error_details.info = e.to_string();
+                        serde_json::to_string(&error_details).unwrap()
+                    }
+                });
+            }
+
+            if rules {
+                let _ = q.send('r').await;
+                result.rules = Some(match q.recv().await {
+                    Ok(p) => format!("{}", p),
+                    Err(e) => {
+                        let mut error_details = ErrorResponse::default();
+                        error_details.error = true;
+                        error_details.info = e.to_string();
+                        serde_json::to_string(&error_details).unwrap()
+                    }
+                });
+            }
+
+            if extra_info {
+                let now = SystemTime::now()
+                    .duration_since(UNIX_EPOCH)
+                    .unwrap()
+                    .as_secs();
+
+                let key = format!("{}:{}", ip, port);
+
+                let should_request = {
+                    let mut map = OMP_EXTRA_INFO_LAST_UPDATE_LIST.lock().unwrap();
+                    match map.get(&key) {
+                        Some(&last_time)
+                            if now - last_time < OMP_EXTRA_INFO_UPDATE_COOLDOWN_SECS =>
+                        {
+                            false
+                        }
+                        _ => {
+                            map.insert(key.clone(), now);
+                            true
+                        }
+                    }
+                };
+
+                if should_request {
+                    let _ = q.send('o').await;
+                    result.extra_info = Some(match q.recv().await {
+                        Ok(p) => format!("{}", p),
+                        Err(e) => {
+                            let mut error_details = ErrorResponse::default();
+                            error_details.error = true;
+                            error_details.info = e.to_string();
+                            serde_json::to_string(&error_details).unwrap()
+                        }
+                    });
+                }
+            }
+
+            if ping {
+                let _ = q.send('p').await;
+                let before = Instant::now();
+                match q.recv().await {
+                    Ok(_p) => {
+                        result.ping = Some(before.elapsed().as_millis() as u32);
+                    }
+                    Err(_) => {
+                        result.ping = Some(9999);
+                    }
+                }
+            }
+
+            Ok(serde_json::to_string(&result).unwrap())
+        }
+        Err(e) => Err(e.to_string()),
+    }
+}

src/containers/LoadingScreen/index.tsx

@@ -221,7 +221,7 @@ const LoadingScreen = (props: { onEnd: () => void }) => {
     console.log("start", "validateResources");
     const dir = await path.appLocalDataDir();
     const samp = await path.join(dir, "samp");
-    console.log("whaaaaqt?")
+
     if (await fs.exists(samp)) {
       const archive = await path.join(samp, "samp_clients.7z");
       if (await fs.exists(archive)) {

src/hooks/query.ts

@@ -4,6 +4,7 @@ import { queryServer } from "../utils/query";
 import { ListType, Server } from "../utils/types";
 
 const QUERY_INTERVAL_DELAY_MS = 1000;
+const QUERY_TIMES_TO_GET_INFO_THRESHOLD = 5;
 
 export const useQuery = () => {
   const queryTimer = useRef<ReturnType<typeof setInterval> | undefined>(
@@ -12,6 +13,7 @@ export const useQuery = () => {
 
   const { selected, setSelected } = useServers();
   const selectedServer = useRef<Server | undefined>(selected);
+  const queryTimesToGetInfo = useRef<number>(0);
 
   useEffect(() => {
     selectedServer.current = selected;
@@ -31,6 +33,7 @@ export const useQuery = () => {
       clearInterval(queryTimer.current);
       queryTimer.current = undefined;
     } else {
+      queryTimesToGetInfo.current = QUERY_TIMES_TO_GET_INFO_THRESHOLD;
       getServerInfo(srv, listType);
       queryTimer.current = setInterval(() => {
         getServerInfo(srv, listType);
@@ -39,7 +42,18 @@ export const useQuery = () => {
   };
 
   const getServerInfo = (srv: Server, listType: ListType) => {
-    queryServer(srv, listType);
+    queryServer(
+      srv,
+      listType,
+      "all",
+      queryTimesToGetInfo.current != QUERY_TIMES_TO_GET_INFO_THRESHOLD
+    );
+
+    if (queryTimesToGetInfo.current != QUERY_TIMES_TO_GET_INFO_THRESHOLD) {
+      queryTimesToGetInfo.current++;
+    } else {
+      queryTimesToGetInfo.current = 0;
+    }
   };
 
   return {

src/utils/helpers.ts

@@ -91,8 +91,9 @@ export const fetchServers = async (cached: boolean = true) => {
             offset < PARALLEL_SERVERS_TO_UPDATE_COUNT;
             offset++
           ) {
-            if (response.servers[i + offset])
+            if (response.servers[i + offset]) {
               queryServer(response.servers[i + offset], "internet", "basic");
+            }
           }
         }, 500 + (i / PARALLEL_SERVERS_TO_UPDATE_COUNT) * PARALLEL_SERVERS_TO_UPDATE_TIMER_INTERVAL);
       }