Patch notes 0.1.10

• Fixed SSEResponse

lib.rs:

A rust Web Framework for prototyping and small scale applications

Simple Hello World HTTP server

use rambl_rs::{Context, HttpResponse, HttpServer, RequestType::Get, Responder};

async fn index(res: Responder, _ctx: Context) {
    res.respond("<h1>Hello World</h1>").await.unwrap();
}

#[tokio::main]
async fn main() {
    let server = HttpServer::new();

    server.on(Get, "/", index);

    server.listen("127.0.0.1:8000").await.unwrap();
}

This shows that some applications don't need alot of code, so we go for minimun boilerplate.

Connection Counter

use rambl_rs::{Context, HttpServer, RequestType::Get, Responder};

async fn index(res: Responder, ctx: Context<i32>) {
    let mut guard = ctx.state.lock().await;
    let counter = guard.as_mut().unwrap();

    *counter += 1;

   res.respond(
        &format!("<h1>You are the {counter} person to view this content</h1>")
   ).await.unwrap();
}

#[tokio::main]
async fn main() {
    let server = HttpServer::new();

    server.manage(0);
    server.on(Get, "/", index);

    server.listen("127.0.0.1:8000").await.unwrap();
}

Real-Time application

this is where rambl_rs shines.

use rambl_rs::RequestType::Post;
use rambl_rs::{Context, HttpServer, RequestType::Get, Responder};
use rambl_rs::{prelude::*, tokio, SSEResponse};
use tokio::sync::broadcast::{channel, Sender};
use std::sync::Arc;

async fn messages(res: Responder, ctx: Context<Arc<Sender<String>>>) {
    let mut rx = Arc::clone(&ctx.state.unwrap_ref()).subscribe();
    let mut sse_res = SSEResponse::new();

    while let Ok(message) = rx.recv().await {
        sse_res.body(message);
        res.respond(&sse_res).await.unwrap();
    }
}

async fn send(res: Responder, ctx: Context<Arc<Sender<String>>>) {
    let tx = Arc::clone(&ctx.state.unwrap_ref());
    let message = ctx.request.body;

    res.respond("").await.unwrap();
    let _ = tx.send(message);
}

#[tokio::main]
async fn main() {
    let server = HttpServer::new();
    let (tx, _) = channel(1);

    server.manage(Arc::new(tx));
    server.on(Get, "/messages", messages);
    server.on(Post, "/send", send);

    server.listen("127.0.0.1:8000").await.unwrap();
}