arnelify_server 0.9.3

<img src="https://static.wikia.nocookie.net/arnelify/images/c/c8/Arnelify-logo-2024.png/revision/latest?cb=20240701012515" style="width:336px;" alt="Arnelify Logo" />

![Arnelify Server for Rust](https://img.shields.io/badge/Arnelify%20Server%20for%20Rust-0.9.3-yellow) ![Rust](https://img.shields.io/badge/Rust-1.91.1-orange) ![Cargo](https://img.shields.io/badge/Cargo-1.91.1-blue)

## 🚀 About

**Arnelify® Server for Rust** — a multi-language server with HTTP 3.0 and WebTransport support.

All supported protocols:
| **#** | **Protocol** | **Transport** |
| - | - | - |
| 1 | TCP1 | HTTP 1.1 |
| 2 | TCP1 | HTTP 2.0 |
| 3 | TCP1 | WebSocket |
| 4 | TCP2 | HTTP 3.0 |
| 5 | TCP2 | WebTransport |

## 📋 Minimal Requirements
> Important: It's strongly recommended to use in a container that has been built from the gcc v15.2.0 image.
* CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
* OS: Debian 11 / MacOS 15 / Windows 10 with <a href="https://learn.microsoft.com/en-us/windows/wsl/install">WSL2</a>.
* RAM: 4 GB

## 📦 Installation
Run in terminal:
```bash
cargo add arnelify_server
```
## 🎉 TCP2 / WebTransport

### 📚 Configuration

| **Option** | **Description** |
| - | - |
| **BLOCK_SIZE_KB**| The size of the allocated memory used for processing large packets. |
| **CERT_PEM**| Path to the TLS cert-file in PEM format. |
| **COMPRESSION**| If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of **BLOCK_SIZE_KB**. |
| **HANDSHAKE_TIMEOUT**| Maximum time in seconds to complete the TLS handshake. |
| **KEY_PEM**| Path to the TLS private key-file in PEM format. |
| **MAX_MESSAGE_SIZE_MB**| Maximum size of a single message the server will accept from a client. |
| **PING_TIMEOUT**| Maximum time the server will wait for a ping from the client. |
| **PORT**| Defines which port the server will listen on. |
| **SEND_TIMEOUT**| Maximum time for the client to receive a response from the server. |
| **THREAD_LIMIT**| Defines the maximum number of threads that will handle requests.|

### 📚 Examples

```rust
use arnelify_server::tcp2::{
    WebTransport, WebTransportBytes, WebTransportCtx, WebTransportHandler, 
    WebTransportLogger, WebTransportOpts, WebTransportStream,
};

use std::sync::{Arc, Mutex};

type JSON = serde_json::Value;

fn main() {
    let wt_opts = WebTransportOpts {
        block_size_kb: 64,
        cert_pem: String::from("certs/cert.pem"),
        compression: true,
        handshake_timeout: 30,
        key_pem: String::from("certs/key.pem"),
        max_message_size_kb: 30,
        ping_timeout: 30,
        port: 4433,
        send_timeout: 30,
        thread_limit: 4,
    };

    let wt = WebTransport::new(wt_opts);

    let wt_logger: Arc<WebTransportLogger> = Arc::new(
        move |_level, message| {
            println!("[Arnelify Server]: {}", message);
        },
    );

    wt.logger(wt_logger);

    let wt_handler: Arc<WebTransportHandler> = Arc::new(
        move |ctx: Arc<Mutex<WebTransportCtx>>,
              bytes: Arc<Mutex<WebTransportBytes>>,
              stream: Arc<Mutex<WebTransportStream>>| {

            let json: JSON = {
                let ctx_lock = ctx.lock().unwrap();
                ctx_lock.clone()
            };

            let bytes_vec = {
                let bytes_lock = bytes.lock().unwrap();
                bytes_lock.clone()
            };

            let mut stream_lock = stream.lock().unwrap();
            stream_lock.push(&json, &bytes_vec);
            stream_lock.close();
        },
    );

    wt.on("connect", wt_handler);
    wt.start();
}
```
## 🎉 TCP2 / HTTP 3.0

### 📚 Configuration

| **Option** | **Description** |
| - | - |
| **ALLOW_EMPTY_FILES**| If this option is enabled, the server will not reject empty files. |
| **BLOCK_SIZE_KB**| The size of the allocated memory used for processing large packets. |
| **CERT_PEM**| Path to the TLS cert-file in PEM format. |
| **CHARSET**| Defines the encoding that the server will recommend to all client applications. |
| **COMPRESSION**| If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of **BLOCK_SIZE_KB**. |
| **KEEP_EXTENSIONS**| If this option is enabled, file extensions will be preserved. |
| **KEY_PEM**| Path to the TLS private key-file in PEM format. |
| **MAX_FIELDS**| Defines the maximum number of fields in the received form. |
| **MAX_FIELDS_SIZE_TOTAL_MB**| Defines the maximum total size of all fields in the form. This option does not include file sizes. |
| **MAX_FILES**| Defines the maximum number of files in the form. |
| **MAX_FILES_SIZE_TOTAL_MB** | Defines the maximum total size of all files in the form. |
| **MAX_FILE_SIZE_MB**| Defines the maximum size of a single file in the form. |
| **PORT**| Defines which port the server will listen on. |
| **STORAGE_PATH**| Specifies the upload directory for storage. |
| **THREAD_LIMIT**| Defines the maximum number of threads that will handle requests. |

### 📚 Examples

```rust
use arnelify_server::tcp2::{
    Http3, Http3Ctx, Http3Handler, Http3Logger, Http3Opts,
    Http3Stream,
};

use std::sync::{Arc, Mutex};

type JSON = serde_json::Value;

fn main() {
    let http3_opts = Http3Opts {
        allow_empty_files: false,
        block_size_kb: 64,
        cert_pem: String::from("certs/cert.pem"),
        charset: String::from("utf-8"),
        compression: true,
        keep_alive: 30,
        keep_extensions: true,
        key_pem: String::from("certs/key.pem"),
        max_fields: 10,
        max_fields_size_total_mb: 1,
        max_files: 3,
        max_files_size_total_mb: 60,
        max_file_size_mb: 60,
        port: 4433,
        storage_path: String::from("/var/www/rs/storage"),
        thread_limit: 4,
    };

    let http3 = Http3::new(http3_opts);

    let http3_logger: Arc<Http3Logger> = Arc::new(
        move |_level, message| {
            println!("[Arnelify Server]: {}", message);
        },
    );

    http3.logger(http3_logger);

    let http3_handler: Arc<Http3Handler> = Arc::new(
        move |ctx: Arc<Mutex<Http3Ctx>>,
              stream: Arc<Mutex<Http3Stream>>| {

            let json: JSON = {
                let ctx_lock = ctx.lock().unwrap();
                ctx_lock.clone()
            };

            let mut stream_lock = stream.lock().unwrap();
            stream_lock.set_code(200);
            stream_lock.push_json(&json, false);
            stream_lock.end();
        },
    );

    http3.on("/", http3_handler);
    http3.start();
}
```

## 🎉 TCP1 / WebSocket

### 📚 Configuration

| **Option** | **Description** |
| - | - |
| **BLOCK_SIZE_KB**| The size of the allocated memory used for processing large packets. |
| **COMPRESSION**| If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of **BLOCK_SIZE_KB**. |
| **HANDSHAKE_TIMEOUT**| Maximum time in seconds to complete the TLS handshake. |
| **MAX_MESSAGE_SIZE_MB**| Maximum size of a single message the server will accept from a client. |
| **PING_TIMEOUT**| Maximum time the server will wait for a ping from the client. |
| **PORT**| Defines which port the server will listen on. |
| **SEND_TIMEOUT**| Maximum time for the client to receive a response from the server. |
| **THREAD_LIMIT**| Defines the maximum number of threads that will handle requests.|

### 📚 Examples

```rust
use arnelify_server::tcp1::{
    WebSocket, WebSocketBytes, WebSocketCtx, WebSocketHandler, 
    WebSocketLogger, WebSocketOpts, WebSocketStream,
};

use std::sync::{Arc, Mutex};

type JSON = serde_json::Value;

fn main() {
    let ws_opts = WebSocketOpts {
        block_size_kb: 64,
        compression: false,
        handshake_timeout: 30,
        max_message_size_kb: 30,
        ping_timeout: 30,
        port: 4433,
        send_timeout: 30,
        thread_limit: 4,
    };

    let ws = WebSocket::new(ws_opts);

    let ws_logger: Arc<WebSocketLogger> = Arc::new(
        move |_level, message| {
            println!("[Arnelify Server]: {}", message);
        },
    );

    ws.logger(ws_logger);

    let ws_handler: Arc<WebSocketHandler> = Arc::new(
        move |ctx: Arc<Mutex<WebSocketCtx>>,
              bytes: Arc<Mutex<WebSocketBytes>>,
              stream: Arc<Mutex<WebSocketStream>>| {

            let json: JSON = {
                let ctx_lock = ctx.lock().unwrap();
                ctx_lock.clone()
            };

            let bytes_vec = {
                let bytes_lock = bytes.lock().unwrap();
                bytes_lock.clone()
            };

            let mut stream_lock = stream.lock().unwrap();
            stream_lock.push(&json, &bytes_vec);
            stream_lock.close();
        },
    );

    ws.on("connect", ws_handler);
    ws.start();
}
```

## 🎉 TCP1 / HTTP 2.0

### 📚 Configuration

| **Option** | **Description** |
| - | - |
| **ALLOW_EMPTY_FILES**| If this option is enabled, the server will not reject empty files. |
| **BLOCK_SIZE_KB**| The size of the allocated memory used for processing large packets. |
| **CERT_PEM**| Path to the TLS cert-file in PEM format. |
| **CHARSET**| Defines the encoding that the server will recommend to all client applications. |
| **COMPRESSION**| If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of **BLOCK_SIZE_KB**. |
| **KEEP_EXTENSIONS**| If this option is enabled, file extensions will be preserved. |
| **KEY_PEM**| Path to the TLS private key-file in PEM format. |
| **MAX_FIELDS**| Defines the maximum number of fields in the received form. |
| **MAX_FIELDS_SIZE_TOTAL_MB**| Defines the maximum total size of all fields in the form. This option does not include file sizes. |
| **MAX_FILES**| Defines the maximum number of files in the form. |
| **MAX_FILES_SIZE_TOTAL_MB** | Defines the maximum total size of all files in the form. |
| **MAX_FILE_SIZE_MB**| Defines the maximum size of a single file in the form. |
| **PORT**| Defines which port the server will listen on. |
| **STORAGE_PATH**| Specifies the upload directory for storage. |
| **THREAD_LIMIT**| Defines the maximum number of threads that will handle requests. |

### 📚 Examples

```rust
use arnelify_server::tcp1::{
    Http2, Http2Ctx, Http2Handler, Http2Logger, Http2Opts,
    Http2Stream,
};

use std::sync::{Arc, Mutex};

type JSON = serde_json::Value;

fn main() {
    let http2_opts = Http2Opts {
        allow_empty_files: false,
        block_size_kb: 1024,
        cert_pem: String::from("certs/cert.pem"),
        charset: String::from("utf-8"),
        compression: true,
        keep_alive: 30,
        keep_extensions: true,
        key_pem: String::from("certs/key.pem"),
        max_fields: 10,
        max_fields_size_total_mb: 1,
        max_files: 1,
        max_files_size_total_mb: 10,
        max_file_size_mb: 10,
        port: 4433,
        storage_path: String::from("/var/www/rs/storage"),
        thread_limit: 4,
    };

    let http2 = Http2::new(http2_opts);

    let http2_logger: Arc<Http2Logger> = Arc::new(
        move |_level, message| {
            println!("[Arnelify Server]: {}", message);
        },
    );

    http2.logger(http2_logger);

    let http2_handler: Arc<Http2Handler> = Arc::new(
        move |ctx: Arc<Mutex<Http2Ctx>>,
              stream: Arc<Mutex<Http2Stream>>| {

            let json: JSON = {
                let ctx_lock = ctx.lock().unwrap();
                ctx_lock.clone()
            };

            let mut stream_lock = stream.lock().unwrap();
            stream_lock.set_code(200);
            stream_lock.push_json(&json, false);
            stream_lock.end();
        },
    );

    http2.on("/", http2_handler);
    http2.start();
}
```

## 🎉 TCP1 / HTTP 1.1

### 📚 Configuration

| **Option** | **Description** |
| - | - |
| **ALLOW_EMPTY_FILES**| If this option is enabled, the server will not reject empty files. |
| **BLOCK_SIZE_KB**| The size of the allocated memory used for processing large packets. |
| **CHARSET**| Defines the encoding that the server will recommend to all client applications. |
| **COMPRESSION**| If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of **BLOCK_SIZE_KB**. |
| **KEEP_EXTENSIONS**| If this option is enabled, file extensions will be preserved. |
| **MAX_FIELDS**| Defines the maximum number of fields in the received form. |
| **MAX_FIELDS_SIZE_TOTAL_MB**| Defines the maximum total size of all fields in the form. This option does not include file sizes. |
| **MAX_FILES**| Defines the maximum number of files in the form. |
| **MAX_FILES_SIZE_TOTAL_MB** | Defines the maximum total size of all files in the form. |
| **MAX_FILE_SIZE_MB**| Defines the maximum size of a single file in the form. |
| **PORT**| Defines which port the server will listen on. |
| **STORAGE_PATH**| Specifies the upload directory for storage. |
| **THREAD_LIMIT**| Defines the maximum number of threads that will handle requests. |

### 📚 Examples

```rust
use arnelify_server::tcp1::{
    Http1, Http1Ctx, Http1Handler, Http1Logger, Http1Opts, 
    Http1Stream,
};

use std::sync::{Arc, Mutex};

type JSON = serde_json::Value;

fn main() {
    let http1_opts = Http1Opts {
        allow_empty_files: false,
        block_size_kb: 64,
        charset: String::from("utf-8"),
        compression: true,
        keep_alive: 30,
        keep_extensions: true,
        max_fields: 10,
        max_fields_size_total_mb: 1,
        max_files: 3,
        max_files_size_total_mb: 60,
        max_file_size_mb: 60,
        port: 4433,
        storage_path: String::from("/var/www/rs/storage"),
        thread_limit: 4,
    };

    let http1 = Http1::new(http1_opts);

    let http1_logger: Arc<Http1Logger> = Arc::new(move |_level, message| {
        println!("[Arnelify Server]: {}", message);
    });

    http1.logger(http1_logger);

    let http1_handler: Arc<Http1Handler> = Arc::new(
        move |ctx: Arc<Mutex<Http1Ctx>>, stream: Arc<Mutex<Http1Stream>>| {
            let json: JSON = {
                let ctx_lock = ctx.lock().unwrap();
                ctx_lock.clone()
            };

            let mut stream_lock = stream.lock().unwrap();
            stream_lock.set_code(200);
            stream_lock.push_json(&json, false);
            stream_lock.end();
        },
    );

    http1.on("/", http1_handler);
    http1.start();
}
```

## ⚖️ MIT License
This software is licensed under the <a href="https://github.com/arnelify/arnelify-server-rust/blob/main/LICENSE">MIT License</a>. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

## 🛠️ Contributing
Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

Run in terminal:
```bash
docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash
```
For TCP2 / WebTransport:
```bash
cargo run --bin test_wt
```
For TCP2 / HTTP 3.0:
```bash
cargo run --bin test_http3
```
For TCP1 / WebSocket:
```bash
cargo run --bin test_ws
```
For TCP1 / HTTP 2.0:
```bash
cargo run --bin test_http2
```
For TCP1 / HTTP 1.1:
```bash
cargo run --bin test_http1
```

## ⭐ Release Notes
Version 0.9.3 — a multi-language server with HTTP 3.0 and WebTransport support.

We are excited to introduce the Arnelify Server for Rust! Please note that this version is raw and still in active development.

Change log:

* Async Multi-Threading.
* Block processing in "on-the-fly" mode.
* BROTLI compression (still in development).
* FFI, PYO3 and NEON support.
* Significant refactoring and optimizations.

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

## 🔗 Links

* <a href="https://github.com/arnelify/arnelify-pod-cpp">Arnelify POD for C++</a>
* <a href="https://github.com/arnelify/arnelify-pod-node">Arnelify POD for NodeJS</a>
* <a href="https://github.com/arnelify/arnelify-pod-python">Arnelify POD for Python</a>
* <a href="https://github.com/arnelify/arnelify-pod-rust">Arnelify POD for Rust</a>
* <a href="https://github.com/arnelify/arnelify-react-native">Arnelify React Native</a>