https://github.com/pgiii/nucleus-http

Rust Web Framework for WebApps and Servers
https://github.com/pgiii/nucleus-http

html http http-server rust web web-framework website

Last synced: about 1 month ago
JSON representation

Rust Web Framework for WebApps and Servers

• Host: GitHub
• URL: https://github.com/pgiii/nucleus-http
• Owner: PGIII
• License: mit
• Created: 2023-02-16T21:12:22.000Z (almost 2 years ago)
• Default Branch: main
• Last Pushed: 2023-08-21T19:46:33.000Z (over 1 year ago)
• Last Synced: 2024-12-06T16:43:53.429Z (about 2 months ago)
• Topics: html, http, http-server, rust, web, web-framework, website
• Language: Rust
• Homepage:
• Size: 227 KB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE.md

Awesome Lists containing this project

README

        
# nucleus-http

Rust Web frame work

## Basic Example With State and Serving Static Files

``` rust

use nucleus_http::{

    request::Request,

    routes::{Route, Router},

    Server,

};

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

use tracing_subscriber::prelude::*;

use tracing_subscriber::{fmt, EnvFilter};

#[derive(Debug, Clone)]

struct AppState {

    greeting: String,

    bye: String,

    views: Arc>,

}

#[tokio::main]

async fn main() -> tokio::io::Result<()> {

    let fmt_layer = fmt::layer()

        .with_target(false)

        .with_thread_names(true)

        .pretty();

    let filter_layer = EnvFilter::try_from_default_env()

        .or_else(|_| EnvFilter::try_new("debug"))

        .unwrap();

    tracing_subscriber::registry()

        .with(filter_layer)

        .with(fmt_layer)

        .init();

    let listener_ip = "0.0.0.0:7878";

    log::info!("Listening on {listener_ip}");

    let state = AppState {

        greeting: "HI".to_owned(),

        bye: "Bye".to_owned(),

        views: Arc::new(RwLock::new(0)),

    };

    let mut router = Router::new(state);

    let route = Route::get("/state", print_greeting);

    router.add_route(route).await;

    router.add_route(Route::get("/hello", get)).await;

    router.add_route(Route::get_static("/", "index.html")).await;

    let server = Server::bind(listener_ip, router.clone(), "./").await?;

    server.serve().await.unwrap();

    Ok(())

}

async fn print_greeting(state: AppState, request: Request) -> Result {

    let mut views_write = state.views.write().unwrap();

    let response = format!(

        "{} {} and {}, Viewed: {}",

        state.greeting,

        request.path(),

        state.bye,

        views_write

    );

    *views_write += 1;

    Ok(response)

}

async fn get(_: AppState, _: Request) -> Result {

    Ok("Hello From Sync Func".to_string())

}

```