sokoke 0.0.2

Web application framework
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

#![allow(dead_code)]

//------------------------------------------------------------------------------
/// # Sokoke
///
/// Web application framework for Rust.
///
///
/// ## Usage
///
/// ```rust
/// use sokoke::App;
///
/// fn main()
/// {
///    let app = App::new();
///    app.run();
/// }
/// ```
//------------------------------------------------------------------------------

use std::env;

use tokio::runtime::Builder;
use tokio::net::TcpListener;


//------------------------------------------------------------------------------
/// Application
//------------------------------------------------------------------------------
pub struct App
{
}

impl App
{
    //--------------------------------------------------------------------------
    /// Creates a new Sokoke application.
    //--------------------------------------------------------------------------
    pub fn new() -> Self
    {
        Self {}
    }

    //--------------------------------------------------------------------------
    /// Returns the version of the application.
    //--------------------------------------------------------------------------
    pub fn version( &self ) -> String
    {
        env::var("CARGO_PKG_VERSION")
            .unwrap_or_else(|_| String::from("unknown"))
    }

    //--------------------------------------------------------------------------
    /// Runs the application.
    //--------------------------------------------------------------------------
    pub fn run( &self )
    {
        // Creates a TCP listener which will listen for incoming connections.

        // Creates a multi-threaded Tokio runtime.
        let runtime = Builder::new_multi_thread()
            .enable_all()
            .worker_threads(4)
            .build()
            .unwrap();
        runtime.block_on(async
        {
            println!("sokoke: {}", self.version());

            // Starts listening for incoming connections.
            let listener = TcpListener::bind("127.0.0.1:3000").await.unwrap();
            self.serve(listener).await;
        });
    }

    //--------------------------------------------------------------------------
    /// Serves the service with the given listener.
    //--------------------------------------------------------------------------
    async fn serve( &self, tcp_listener: TcpListener )
    {
        loop
        {
            let (_stream, _remote_addr) = tcp_listener.accept().await.unwrap();
        }
    }
}


//------------------------------------------------------------------------------
/// Tests
//------------------------------------------------------------------------------
#[cfg(test)]
mod tests
{
    use super::*;

    //--------------------------------------------------------------------------
    /// Tests the application.
    //--------------------------------------------------------------------------
    #[test]
    fn test_app()
    {
        let app = App::new();
        app.run();
    }
}