product-os-server 0.0.55

Product OS : Server provides a full functioning advanced server capable of acting as a web server, command and control distributed network, authentication server, crawling server and more. Fully featured with high level of flexibility.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! WebSocket Example
//!
//! This example demonstrates how to handle WebSocket connections.

use product_os_server::ProductOSServer;

#[cfg(not(feature = "ws"))]
use product_os_server::{StatusCode, Response, Body};
use product_os_server::ServerConfig;
use product_os_async_executor::TokioExecutor;

#[cfg(feature = "ws")]
use axum::{
    extract::ws::{WebSocketUpgrade, WebSocket, Message},
    response::IntoResponse,
};

#[cfg(feature = "ws")]
use futures::{sink::SinkExt, stream::{StreamExt, SplitSink, SplitStream}};

#[cfg(feature = "ws")]
async fn ws_handler(ws: WebSocketUpgrade) -> impl IntoResponse {
    ws.on_upgrade(handle_socket)
}

#[cfg(feature = "ws")]
async fn handle_socket(mut socket: WebSocket) {
    while let Some(msg) = socket.recv().await {
        let msg = if let Ok(msg) = msg {
            msg
        } else {
            // client disconnected
            return;
        };

        if socket.send(msg).await.is_err() {
            // client disconnected
            return;
        }
    }
}

#[cfg(feature = "ws")]
async fn ws_concurrent_handler(ws: WebSocketUpgrade) -> impl IntoResponse {
    ws.on_upgrade(handle_socket_concurrent)
}

#[cfg(feature = "ws")]
async fn handle_socket_concurrent(socket: WebSocket) {
    let (sender, receiver) = socket.split();

    tokio::spawn(write_messages(sender));
    tokio::spawn(read_messages(receiver));
}

#[cfg(feature = "ws")]
async fn read_messages(mut receiver: SplitStream<WebSocket>) {
    while let Some(Ok(msg)) = receiver.next().await {
        println!("Received message: {:?}", msg);
    }
}

#[cfg(feature = "ws")]
async fn write_messages(mut sender: SplitSink<WebSocket, Message>) {
    use tokio::time::{interval, Duration};
    
    let mut interval = interval(Duration::from_secs(1));
    
    for i in 0..10 {
        interval.tick().await;
        let msg = Message::Text(format!("Server message {}", i).into());
        if sender.send(msg).await.is_err() {
            break;
        }
    }
}

#[cfg(not(feature = "ws"))]
async fn fallback_handler() -> Result<Response<Body>, StatusCode> {
    Ok(Response::builder()
        .status(StatusCode::NOT_IMPLEMENTED)
        .body(Body::from("WebSocket feature not enabled"))
        .unwrap())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing
    tracing_subscriber::fmt::init();

    // Create configuration
    let mut config = ServerConfig::new();
    config.network.port = 3000;

    println!("Creating WebSocket server...");
    
    // Create server
    let mut server: ProductOSServer<(), TokioExecutor, _> = 
        ProductOSServer::new_with_config(config);

    #[cfg(feature = "ws")]
    {
        // Add WebSocket routes
        server.add_ws_handler("/ws", ws_handler);
        server.add_ws_handler("/ws/concurrent", ws_concurrent_handler);
        
        println!("WebSocket Server listening on http://localhost:3000");
        println!("Try connecting to:");
        println!("  ws://localhost:3000/ws");
        println!("  ws://localhost:3000/ws/concurrent");
        println!("");
        println!("Example with websocat:");
        println!("  websocat ws://localhost:3000/ws");
    }

    #[cfg(not(feature = "ws"))]
    {
        server.add_get("/", fallback_handler);
        println!("WebSocket feature not enabled. Rebuild with --features ws");
    }

    // Start server
    server.start(false).await.map_err(|e| format!("Server error: {}", e))?;

    // Keep the main thread alive
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
    }
}