Skip to main content

clm_rust_core/layer3/
network_gateway.rs

1use std::collections::HashSet;
2use std::path::{Path, PathBuf};
3use std::sync::Arc;
4use tokio::net::{TcpListener, TcpStream};
5use tokio::io::AsyncWriteExt;
6#[cfg(unix)]
7use tokio::net::UnixStream;
8
9use tokio::sync::Mutex;
10use tokio::time::{sleep, Duration};
11use futures_util::{StreamExt, SinkExt};
12use tokio_tungstenite::accept_async;
13use tokio_tungstenite::tungstenite::Message;
14use serde::Serialize;
15use serde_json::Value;
16use regex::Regex;
17
18#[derive(Clone)]
19pub struct NetworkGateway {
20    pub host: String,
21    pub port: u16,
22    pub timeout: u64,
23}
24
25#[derive(Serialize)]
26struct StatusResponse<'a> {
27    #[serde(rename = "type")]
28    msg_type: &'static str,
29    status: &'static str,
30    clm: &'a str,
31    payload: &'a str,
32}
33
34#[derive(Serialize)]
35struct ErrorResponse<'a> {
36    #[serde(rename = "type")]
37    msg_type: &'static str,
38    error: &'a str,
39    #[serde(skip_serializing_if = "Option::is_none")]
40    exit_code: Option<i32>,
41}
42
43#[allow(dead_code)]
44#[derive(Serialize)]
45struct LogResponse<'a> {
46    #[serde(rename = "type")]
47    msg_type: &'static str,
48    message: &'a str,
49}
50
51#[derive(Serialize)]
52struct CompletedResponse<'a> {
53    #[serde(rename = "type")]
54    msg_type: &'static str,
55    exit_code: i32,
56    #[serde(skip_serializing_if = "Option::is_none")]
57    witness_hash: Option<&'a str>,
58    #[serde(skip_serializing_if = "Option::is_none")]
59    witness_yaml: Option<&'a str>,
60    #[serde(skip_serializing_if = "Option::is_none")]
61    result: Option<&'static str>,
62}
63
64type WsWriter = Arc<Mutex<futures_util::stream::SplitSink<tokio_tungstenite::WebSocketStream<TcpStream>, Message>>>;
65
66// Response message serialization helpers
67async fn send_error(writer: &WsWriter, error: &str, exit_code: Option<i32>) {
68    let err_res = ErrorResponse {
69        msg_type: "error",
70        error,
71        exit_code,
72    };
73    if let Ok(json_str) = serde_json::to_string(&err_res) {
74        let mut writer_lock = writer.lock().await;
75        let _ = writer_lock.send(Message::Text(json_str)).await;
76    }
77}
78
79async fn send_status(writer: &WsWriter, status: &'static str, clm: &str, payload: &str) {
80    let start_res = StatusResponse {
81        msg_type: "status",
82        status,
83        clm,
84        payload,
85    };
86    if let Ok(json_str) = serde_json::to_string(&start_res) {
87        let mut writer_lock = writer.lock().await;
88        let _ = writer_lock.send(Message::Text(json_str)).await;
89    }
90}
91
92#[allow(dead_code)]
93async fn send_log(writer: &WsWriter, message: &str) {
94    let log_res = LogResponse {
95        msg_type: "log",
96        message,
97    };
98    if let Ok(json_str) = serde_json::to_string(&log_res) {
99        let mut writer_lock = writer.lock().await;
100        let _ = writer_lock.send(Message::Text(json_str)).await;
101    }
102}
103
104async fn send_completed(
105    writer: &WsWriter,
106    exit_code: i32,
107    witness_hash: Option<&str>,
108    witness_yaml: Option<&str>,
109    result: Option<&'static str>,
110) {
111    let completed_res = CompletedResponse {
112        msg_type: "completed",
113        exit_code,
114        witness_hash,
115        witness_yaml,
116        result,
117    };
118    if let Ok(json_str) = serde_json::to_string(&completed_res) {
119        let mut writer_lock = writer.lock().await;
120        let _ = writer_lock.send(Message::Text(json_str)).await;
121    }
122}
123
124async fn send_chat_token(writer: &WsWriter, token: &str) {
125    let token_msg = serde_json::json!({
126        "type": "chat_token",
127        "token": token
128    }).to_string();
129    let mut writer_lock = writer.lock().await;
130    let _ = writer_lock.send(Message::Text(token_msg)).await;
131}
132
133impl Default for NetworkGateway {
134    fn default() -> Self {
135        Self::new()
136    }
137}
138
139impl NetworkGateway {
140    pub fn new() -> Self {
141        let payload = crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_PAYLOAD).unwrap_or_default();
142        let mut host = "127.0.0.1".to_string();
143        let mut port = crate::layer0::provider_profiles::provider_port(crate::layer0::vocabulary_types::PROVIDER_LOCAL_LLM, crate::layer0::vocabulary_types::PROVIDER_FIELD_GATEWAY_PORT);
144        let mut timeout = 30000;
145
146        if !payload.is_empty() {
147            if let Ok(host_re) = Regex::new(r"host=([^\s]+)")
148                && let Some(caps) = host_re.captures(&payload)
149                    && let Some(m) = caps.get(1) {
150                        host = m.as_str().to_string();
151                    }
152            if let Ok(port_re) = Regex::new(r"port=(\d+)")
153                && let Some(caps) = port_re.captures(&payload)
154                    && let Some(m) = caps.get(1)
155                        && let Ok(p) = m.as_str().parse::<u16>() {
156                            port = p;
157                        }
158            if let Ok(timeout_re) = Regex::new(r"timeout=(\d+)")
159                && let Some(caps) = timeout_re.captures(&payload)
160                    && let Some(m) = caps.get(1)
161                        && let Ok(t) = m.as_str().parse::<u64>() {
162                            timeout = t;
163                        }
164        }
165
166        Self { host, port, timeout }
167    }
168
169    pub async fn start(&self) -> Result<(), String> {
170        let addr = format!("{}:{}", self.host, self.port);
171        let listener = TcpListener::bind(&addr).await
172            .map_err(|e| format!("Failed to bind to {}: {}", addr, e))?;
173
174        println!("[GATEWAY] WebSocket Gateway server listening on ws://{}", addr);
175
176        let active_connections = Arc::new(Mutex::new(HashSet::new()));
177        let shutdown_trigger = Arc::new(tokio::sync::Notify::new());
178
179        // Spawn timeout clean sweep
180        let _active_connections_clone = Arc::clone(&active_connections);
181        let shutdown_trigger_clone = Arc::clone(&shutdown_trigger);
182        let timeout_duration = self.timeout;
183        tokio::spawn(async move {
184            sleep(Duration::from_millis(timeout_duration)).await;
185            println!("[GATEWAY] Reached timeout of {}ms. Shutting down.", timeout_duration);
186            shutdown_trigger_clone.notify_one();
187        });
188
189        loop {
190            tokio::select! {
191                _ = shutdown_trigger.notified() => {
192                    break;
193                }
194                accept_res = listener.accept() => {
195                    match accept_res {
196                        Ok((stream, _)) => {
197                            let active_connections = Arc::clone(&active_connections);
198                            let shutdown_trigger = Arc::clone(&shutdown_trigger);
199                            tokio::spawn(async move {
200                                if let Err(e) = handle_connection(stream, active_connections, shutdown_trigger).await {
201                                    eprintln!("[GATEWAY] Error handling connection: {}", e);
202                                }
203                            });
204                        }
205                        Err(e) => {
206                            eprintln!("[GATEWAY] Failed to accept connection: {}", e);
207                        }
208                    }
209                }
210            }
211        }
212
213        // Graceful exit
214        Ok(())
215    }
216}
217
218async fn execute_ollama(
219    query_text: &str,
220    json_msg: &Option<Value>,
221    writer: &WsWriter,
222) -> Result<(), String> {
223    println!("[GATEWAY] Entering Ollama fallback logic...");
224    let selected_model = json_msg.as_ref()
225        .and_then(|v| v.get("model").and_then(|m| m.as_str()))
226        .unwrap_or(crate::layer0::provider_profiles::provider_str(crate::layer0::vocabulary_types::PROVIDER_OLLAMA, crate::layer0::vocabulary_types::PROVIDER_FIELD_GATEWAY_MODEL));
227    let ollama_url = crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_OLLAMA_URL).unwrap_or_else(|_| crate::layer0::provider_profiles::provider_str(crate::layer0::vocabulary_types::PROVIDER_OLLAMA, crate::layer0::vocabulary_types::PROVIDER_FIELD_LOOPBACK_URL).to_string());
228    
229    let ollama_host;
230    let mut ollama_port = crate::layer0::provider_profiles::provider_port(crate::layer0::vocabulary_types::PROVIDER_OLLAMA, crate::layer0::vocabulary_types::PROVIDER_FIELD_PORT);
231
232    // Parse basic host/port
233    let temp = ollama_url.trim_start_matches(crate::layer0::vocabulary::URI_SCHEME_HTTP).trim_start_matches(crate::layer0::vocabulary::URI_SCHEME_HTTPS);
234    let temp = temp.split('/').next().unwrap_or(temp);
235    if let Some(idx) = temp.find(':') {
236        ollama_host = temp[..idx].to_string();
237        if let Ok(p) = temp[idx + 1..].parse::<u16>() {
238            ollama_port = p;
239        }
240    } else {
241        ollama_host = temp.to_string();
242    }
243
244    let mut system_content = "You are a friendly and helpful AI math assistant inside the GASING (Gampang, Asyik, Menyenangkan) interactive learning game. Keep your answers brief, encouraging, and clear for kids.".to_string();
245    if let Some(val) = json_msg
246        && let Some(game_id) = val.get("gameId").and_then(|g| g.as_str()) {
247            system_content.push_str(&format!("\nCurrent Game context:\n- Game ID: {}\n- Round: {}", game_id, val.get("round").and_then(|r| r.as_u64()).unwrap_or(1)));
248            if let Some(q) = val.get("question").and_then(|q| q.as_str()) {
249                system_content.push_str(&format!("\n- Current Problem: {}", q));
250            }
251            if let Some(exp) = val.get("gasingExplanation").and_then(|e| e.as_str()) {
252                system_content.push_str(&format!("\n- GASING Methodology/Explanation: {}", exp));
253            }
254        }
255
256    let post_data = serde_json::json!({
257        "model": selected_model,
258        "messages": [
259            { "role": "system", "content": system_content },
260            { "role": "user", "content": query_text }
261        ],
262        "stream": true
263    }).to_string();
264
265    // Send status
266    send_status(writer, "started", &format!("Ollama ({})", selected_model), query_text).await;
267
268    match TcpStream::connect(format!("{}:{}", ollama_host, ollama_port)).await {
269        Ok(mut tcp_stream) => {
270            let request_headers = format!(
271                "POST /api/chat HTTP/1.1\r\n\
272                 Host: {}:{}\r\n\
273                 Content-Type: application/json\r\n\
274                 Content-Length: {}\r\n\
275                 Connection: close\r\n\r\n{}",
276                ollama_host, ollama_port, post_data.len(), post_data
277            );
278            if tcp_stream.write_all(request_headers.as_bytes()).await.is_ok() {
279                let mut reader = tokio::io::BufReader::new(tcp_stream);
280                let mut line = String::new();
281                use tokio::io::AsyncBufReadExt;
282                
283                // Skip HTTP response headers
284                loop {
285                    line.clear();
286                    if reader.read_line(&mut line).await.unwrap_or(0) == 0 {
287                        break;
288                    }
289                    if line.trim().is_empty() {
290                        break;
291                    }
292                }
293
294                // Read HTTP body line by line
295                loop {
296                    line.clear();
297                    if reader.read_line(&mut line).await.unwrap_or(0) == 0 {
298                        break;
299                    }
300                    let trimmed = line.trim();
301                    if trimmed.is_empty() {
302                        continue;
303                    }
304                    if let Ok(parsed) = serde_json::from_str::<Value>(trimmed)
305                        && let Some(token) = parsed.get("message").and_then(|m| m.get("content")).and_then(|c| c.as_str()) {
306                            send_chat_token(writer, token).await;
307                        }
308                }
309            }
310            send_completed(writer, 0, None, None, None).await;
311        }
312        Err(err) => {
313            send_error(writer, &format!("Ollama is offline or model could not be loaded. Error: {}", err), None).await;
314        }
315    }
316    Ok(())
317}
318
319
320#[path = "network_gateway_handlers.rs"]
321mod network_gateway_handlers;
322#[allow(unused_imports)]
323pub use network_gateway_handlers::*;