Initial commit

src/main.rs

@@ -0,0 +1,135 @@
+use diesel::prelude::*;
+use std::env;
+use std::sync::Arc;
+use anyhow::{anyhow, Result, Context};
+use askama_axum::Template;
+use axum::{
+    extract::{Path, State},
+    http::{Method, header, StatusCode, Request, Uri},
+    response::{IntoResponse, Response, Html},
+    routing::{get, post},
+    Json, Router,
+};
+use deadpool_diesel::sqlite::{Runtime, Manager, Pool};
+use clap::Parser;
+use tokio::sync::Mutex;
+use tower::{ServiceBuilder};
+use tower_http::{
+    cors::{Any, CorsLayer},
+    trace::{TraceLayer, DefaultOnResponse},
+    LatencyUnit
+};
+use tracing::{
+    info, error, debug, info_span, enabled,
+    instrument, Level, Span
+};
+
+pub mod models;
+pub mod schema;
+
+use self::models::*;
+
+#[derive(Parser,Clone)]
+struct Config {
+    #[arg(long,env)]
+    database_url: String,
+    #[arg(long,env)]
+    http_host: String,
+    #[arg(long,env)]
+    http_port: u16,
+}
+
+#[derive(Clone)]
+struct AppContext {
+    config: Config,
+    pool: Pool,
+    counter: Arc<Mutex<i32>>
+}
+
+async fn establish_connection(database_url: &str) -> Pool {
+    let manager = Manager::new(database_url, Runtime::Tokio1);
+    let pool = Pool::builder(manager)
+        .max_size(8)
+        .build()
+        .unwrap();
+    let _ = pool.get().await.expect("DB connection failed"); // Test if DB connection was fine
+    pool
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Load Env File
+    dotenvy::dotenv().ok();
+    // Init Tracing
+    tracing_subscriber::fmt::init();
+    // Parse Env/CLI
+    let config = Config::parse();
+    // Establish Connection Pool
+    let pool: Pool = establish_connection(&config.database_url).await;
+    // Prepare Web Server Context
+    let context = AppContext {
+        config: config.clone(),
+        pool: pool.clone(),
+        counter: Arc::new(Mutex::new(0)),
+    };
+    // Prepare Middlewares
+    let cors = CorsLayer::very_permissive();
+    let tracelayer = TraceLayer::new_for_http()
+        .make_span_with(|request: &Request<_>| {
+            // Log the matched route's path (with placeholders not filled in).
+            let path = request.uri().to_string();
+            info_span!(
+                "request",
+                method = ?request.method(),
+                path
+            )
+        })
+        .on_request(|_request: &Request<_>, _span: &Span| {
+            debug!("Request received");
+        })
+        .on_response(
+            DefaultOnResponse::new()
+                .level(Level::DEBUG)
+                .latency_unit(LatencyUnit::Millis)
+        );
+    let middlewares = ServiceBuilder::new()
+        .layer(tracelayer).layer(cors);
+    // Launch Web Server
+    let app = Router::new()
+        .route("/", get(index))
+        .layer(middlewares)
+        .with_state(context.clone());
+    // Run our app with hyper
+    let listener = tokio::net::TcpListener::bind((config.http_host.as_str(), config.http_port))
+        .await.context(format!("Failed to bind Web Service on {}:{}", config.http_host, config.http_port))?;
+    info!("Listening on {}:{}", config.http_host, config.http_port);
+    axum::serve(listener, app).await.context("Failed to serve Web Service")?;
+    // let connection = &mut establish_connection();
+    // use self::schema::rss_feeds::dsl::*;
+    // let results = rss_feeds
+    //     .limit(5)
+    //     .select(RssFeed::as_select())
+    //     .load(connection)
+    //     .expect("Error loading posts");
+    //
+    // println!("Displaying {} posts", results.len());
+    // for rss_feed in results {
+    //     println!("{}", rss_feed.name);
+    //     println!("-----------\n");
+    //     println!("{}", rss_feed.feed_url);
+    // }
+    Ok(())
+}
+
+
+#[derive(Template)]
+#[template(path = "index.html")]
+struct HelloTemplate<'a> {
+    name: &'a str,
+}
+
+async fn index(
+    State(ctx): State<AppContext>,
+) -> HelloTemplate<'static> {
+    HelloTemplate { name: "world" }
+}

src/models.rs

@@ -0,0 +1,11 @@
+use diesel::prelude::*;
+
+#[derive(Queryable, Selectable)]
+#[diesel(table_name = crate::schema::rss_feeds)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct RssFeed {
+    pub id: i32,
+    pub name: String,
+    pub feed_url: String,
+    pub last_pub_date: Option<String>,
+}

src/schema.rs

@@ -0,0 +1,10 @@
+// @generated automatically by Diesel CLI.
+
+diesel::table! {
+    rss_feeds (id) {
+        id -> Integer,
+        name -> Text,
+        feed_url -> Text,
+        last_pub_date -> Nullable<Text>,
+    }
+}