rastapi 0.1.0

REST API library inspired by python FastAPI/Flask
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

# RastAPI

**RastAPI** is an easy-to-use Rust library for creating low-boilerplate, efficient RESTful APIs, inspired by FastAPI (Python). Define route handlers (functions) and map them to their corresponding URLs to get a fully functional API.

RastAPI is designed with **Non-Blocking I/O** and a **Threadpool** architecture for efficient and concurrent request handling. It also features an advanced **LFU-LRU-based file caching system**, leveraging multithreading with lock-stripping techniques to minimize contention.

---

## Features

- Minimal boilerplate for defining routes and handlers.
- High performance leveraging Rust’s concurrency and safety.
- Efficient file uploads and downloads.

---

## Installation

Add the following to your `Cargo.toml`:

```toml
[dependencies]
rastapi = "0.1.0" # Replace with the latest version
```
## Usage

### Text or JSON content
Define routes and handlers to serve text or JSON content using `create_response` function.
```rust
use rastapi::RastAPI;
use rastapi::Request::HttpRequest;
use rastapi::Response::{HttpResponse, create_response};
use rastapi::utils::ContentType;
use std::collections::HashMap;

// Define a route handler function.
// Signature: fn(request: &HttpRequest, path_params: HashMap<String, String>) -> HttpResponse
fn json(request_obj: &HttpRequest, path_params: HashMap<String, String>) -> HttpResponse {
    let json_content = r#"{
        "name": "Rony",
        "batch": 2024,
        "sem": 3,
        "subjects": ["OS", "Networking", "Algorithms"],
        "grade": {
            "OS": "C",
            "Cryptography": "C",
            "Algorithms": "C"
        }
    }"#;

    let resp = create_response(&json_content, 200, ContentType::JSON, true).unwrap();
    resp
}

fn main() {
    let mut app = RastAPI::new();
    app.set_total_workers(5); // Set the number of threads in the threadpool.
    app.register_route("/json", vec!["GET"], json); // Register the route handler.
    app.run("0.0.0.0", 5000); // Start the server.
}
```
### File Content
Similarly you can serve file content using `send_file`. If a file is not found, the server automatically responds with `404 Not Found`.
```rust
use rastapi::RastAPI;
use rastapi::Request::HttpRequest;
use rastapi::Response::{HttpResponse, send_file};
use rastapi::utils::FileType;
use std::collections::HashMap;

fn file(req: &HttpRequest, path_params: HashMap<String, String>) -> HttpResponse {
    let mut resp = send_file(
        "file_path/file_name.ext",
        Some("file_name.ext".to_string()),
        FileType::MP4,
        200,
        true,
    )
    .unwrap();

    resp.add_header("Header-Name", "Header-Value");
    resp
}

fn main() {
    let mut app = RastAPI::new();
    app.set_total_workers(5);
    app.register_route("/file", vec!["GET"], file);
    app.run("127.0.0.1", 5000);
}
```
## Future Work
- [ ] Don't avoid the rust borrow checker and take it head on. For example using `&str` instead of `String`.
- [ ] Building a more robust logging system.
- [ ] Enable encrypted connections (https). Currently it only supports http.
- [ ] Impliment security fetures like DDOS protection.
- [ ] Building a templating engiene for server side rendering of HTML.
- [ ] Enable support for http2. (maybe) Currently it only supports HTTP/1.0 & HTTP/1.1