[rust/vidi] viz has been renamed to vidi (#10369)

frameworks/Rust/vidi/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "vidi"
+version = "0.1.0"
+edition = "2024"
+publish = false
+authors = ["Fangdun Tsai <[email protected]>"]
+
+[[bin]]
+name = "vidi"
+path = "src/main.rs"
+
+[[bin]]
+name = "vidi-pg"
+path = "src/main_pg.rs"
+required-features = ["tokio-postgres", "yarte"]
+
+[dependencies]
+vidi = "0.1"
+hyper = "1.0"
+hyper-util = "0.1"
+http-body-util = "0.1"
+atoi = "2.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
+mime = "0.3"
+rand = { version = "0.9", features = ["small_rng"] }
+thiserror = "2.0"
+futures-util = "0.3"
+socket2 = { version = "0.6.0", features = ["all"] }
+num_cpus = "1.0"
+
+[target.'cfg(not(unix))'.dependencies]
+nanorand = { version = "0.8" }
+
+[target.'cfg(unix)'.dependencies]
+nanorand = { version = "0.8", features = ["getrandom"] }
+
+tokio = { version = "1", features = ["full"] }
+tokio-postgres = { version = "0.7", optional = true }
+
+yarte = { version = "0.15", features = ["bytes-buf", "json"], optional = true }
+
+[profile.release]
+lto = true
+codegen-units = 1
+strip = true
+opt-level = 3

frameworks/Rust/viz/README.md → frameworks/Rust/vidi/README.md

@@ -1,5 +1,7 @@
-# [viz](https://github.com/viz-rs) web framework
+# [vidi] web framework
 
 ## Description
 
 Fast, robust, flexible, lightweight web framework for Rust.
+
+[vidi]: https://github.com/viz-rs/vidi

frameworks/Rust/vidi/benchmark_config.json

@@ -0,0 +1,47 @@
+{
+  "framework": "vidi",
+  "tests": [
+    {
+      "default": {
+        "json_url": "/json",
+        "plaintext_url": "/plaintext",
+        "port": 8080,
+        "approach": "Realistic",
+        "classification": "Platform",
+        "database": "none",
+        "framework": "Vidi",
+        "language": "Rust",
+        "flavor": "None",
+        "orm": "Raw",
+        "platform": "Rust",
+        "webserver": "Hyper",
+        "os": "Linux",
+        "database_os": "Linux",
+        "display_name": "Vidi",
+        "notes": "",
+        "versus": "None"
+      },
+      "pg": {
+        "db_url": "/db",
+        "fortune_url": "/fortunes",
+        "query_url": "/queries?q=",
+        "update_url": "/updates?q=",
+        "port": 8080,
+        "approach": "Realistic",
+        "classification": "Fullstack",
+        "database": "postgres",
+        "framework": "Vidi",
+        "language": "Rust",
+        "flavor": "None",
+        "orm": "Raw",
+        "platform": "Rust",
+        "webserver": "Hyper",
+        "os": "Linux",
+        "database_os": "Linux",
+        "display_name": "Vidi [Postgresql]",
+        "notes": "",
+        "versus": "None"
+      }
+    }
+  ]
+}

frameworks/Rust/vidi/config.toml

@@ -0,0 +1,30 @@
+[framework]
+name = "vidi"
+
+[main]
+urls.plaintext = "/plaintext"
+urls.json = "/json"
+approach = "Realistic"
+classification = "Micro"
+database = "Postgres"
+database_os = "Linux"
+os = "Linux"
+orm = "Raw"
+platform = "None"
+webserver = "vidi"
+versus = ""
+
+[pg]
+urls.db = "/db"
+urls.query = "/queries?q="
+urls.update = "/updates?q="
+urls.fortune = "/fortunes"
+approach = "Realistic"
+classification = "Fullstack"
+database = "Postgres"
+database_os = "Linux"
+os = "Linux"
+orm = "Raw"
+platform = "None"
+webserver = "vidi"
+versus = ""

frameworks/Rust/viz/src/db_pg.rs → frameworks/Rust/vidi/src/db_pg.rs

@@ -1,10 +1,10 @@
 use std::{collections::HashMap, fmt::Write, io, sync::Arc};
 
-use futures_util::{stream::FuturesUnordered, StreamExt, TryFutureExt, TryStreamExt};
-use rand::{rng, rngs::SmallRng, Rng, SeedableRng};
+use futures_util::{StreamExt, TryFutureExt, TryStreamExt, stream::FuturesUnordered};
+use rand::{Rng, SeedableRng, rng, rngs::SmallRng};
 use tokio::pin;
-use tokio_postgres::{connect, types::ToSql, Client, NoTls, Statement};
-use viz::{Error, IntoResponse, Response, StatusCode};
+use tokio_postgres::{Client, NoTls, Statement, connect, types::ToSql};
+use vidi::{Error, IntoResponse, Response, StatusCode};
 
 use crate::models::{Fortune, World};
 
@@ -21,7 +21,7 @@ pub enum PgError {
 
 impl From<PgError> for Error {
     fn from(e: PgError) -> Self {
-        Error::Responder(e.into_response())
+        Error::Responder(Box::new(e.into_response()))
     }
 }
 

frameworks/Rust/viz/src/main.rs → frameworks/Rust/vidi/src/main.rs

@@ -1,9 +1,9 @@
 #![allow(clippy::unused_async)]
 
 use serde::Serialize;
-use viz::{
-    header::{HeaderValue, CONTENT_TYPE, SERVER},
+use vidi::{
     Bytes, Request, Response, ResponseExt, Result, Router,
+    header::{CONTENT_TYPE, HeaderValue},
 };
 
 mod server;
@@ -14,12 +14,11 @@ struct Message {
     message: &'static str,
 }
 
+const HELLO_WORLD: &str = "Hello, World!";
+
 #[inline(always)]
 async fn plaintext(_: Request) -> Result<Response> {
-    let mut res = Response::text("Hello, World!");
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
+    Ok(Response::text(HELLO_WORLD))
 }
 
 #[inline(always)]
@@ -28,7 +27,7 @@ async fn json(_: Request) -> Result<Response> {
         .body(
             http_body_util::Full::new(Bytes::from(
                 serde_json::to_vec(&Message {
-                    message: "Hello, World!",
+                    message: HELLO_WORLD,
                 })
                 .unwrap(),
             ))
@@ -36,7 +35,6 @@ async fn json(_: Request) -> Result<Response> {
         )
         .unwrap();
     let headers = res.headers_mut();
-    headers.insert(SERVER, HeaderValue::from_static("Viz"));
     headers.insert(
         CONTENT_TYPE,
         HeaderValue::from_static(mime::APPLICATION_JSON.as_ref()),

frameworks/Rust/viz/src/main_pg.rs → frameworks/Rust/vidi/src/main_pg.rs

@@ -1,10 +1,6 @@
 use std::sync::Arc;
 
-use viz::{
-    header::{HeaderValue, SERVER},
-    types::State,
-    Request, RequestExt, Response, ResponseExt, Result, Router,
-};
+use vidi::{Request, RequestExt, Response, ResponseExt, Result, Router, types::State};
 use yarte::Template;
 
 mod db_pg;
@@ -12,7 +8,7 @@ mod models;
 mod server;
 mod utils;
 
-use db_pg::{get_conn, PgConnection};
+use db_pg::{PgConnection, get_conn};
 
 #[derive(Template)]
 #[template(path = "fortune.hbs")]
@@ -28,9 +24,8 @@ async fn db(req: Request) -> Result<Response> {
 
     let world = conn.get_world().await?;
 
-    let mut res = Response::json(world)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
+    let res = Response::json(world)?;
+
     Ok(res)
 }
 
@@ -43,10 +38,7 @@ async fn fortunes(req: Request) -> Result<Response> {
         .call()
         .expect("error rendering template");
 
-    let mut res = Response::html(buf);
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
+    Ok(Response::html(buf))
 }
 
 async fn queries(req: Request) -> Result<Response> {
@@ -55,9 +47,8 @@ async fn queries(req: Request) -> Result<Response> {
 
     let worlds = conn.get_worlds(count).await?;
 
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
+    let res = Response::json(worlds)?;
+
     Ok(res)
 }
 
@@ -67,9 +58,8 @@ async fn updates(req: Request) -> Result<Response> {
 
     let worlds = conn.update(count).await?;
 
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
+    let res = Response::json(worlds)?;
+
     Ok(res)
 }
 

frameworks/Rust/viz/src/server.rs → frameworks/Rust/vidi/src/server.rs

@@ -9,19 +9,28 @@ use hyper::server::conn::http1::Builder;
 use hyper_util::rt::TokioIo;
 use socket2::{Domain, SockAddr, Socket};
 use tokio::{net::TcpListener, runtime};
-use viz::{Responder, Router, Tree};
+use vidi::header::{HeaderValue, SERVER};
+use vidi::{HandlerExt, Responder, Response, Router, Tree};
 
 pub async fn serve(router: Router) -> Result<(), Box<dyn Error + Send + Sync>> {
     let addr = SocketAddr::from((Ipv4Addr::UNSPECIFIED, 8080));
     let socket = create_socket(addr).expect("couldn't bind to addr");
     let listener = TcpListener::from_std(socket.into())?;
 
+    let router = router.map_handler(|h| {
+        h.map(|mut res: Response| {
+            let headers = res.headers_mut();
+            headers.insert(SERVER, HeaderValue::from_static("Vidi"));
+            res
+        })
+        .boxed()
+    });
     let tree = Arc::<Tree>::new(router.into());
 
     let mut http = Builder::new();
     http.pipeline_flush(true);
 
-    println!("Started viz server at 8080");
+    println!("Started vidi server at 8080");
 
     loop {
         let (tcp, _) = listener.accept().await?;

frameworks/Rust/vidi/vidi-pg.dockerfile

@@ -0,0 +1,11 @@
+FROM rust:1.91
+
+ADD ./ /vidi
+WORKDIR /vidi
+
+RUN cargo clean
+RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin vidi-pg --features="tokio-postgres,yarte"
+
+EXPOSE 8080
+
+CMD ./target/release/vidi-pg

frameworks/Rust/viz/viz.dockerfile → frameworks/Rust/vidi/vidi.dockerfile

@@ -1,11 +1,11 @@
-FROM rust:1.89
+FROM rust:1.91
 
-ADD ./ /viz
-WORKDIR /viz
+ADD ./ /vidi
+WORKDIR /vidi
 
 RUN cargo clean
-RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin viz
+RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin vidi
 
 EXPOSE 8080
 
-CMD ./target/release/viz
+CMD ./target/release/vidi

frameworks/Rust/viz/Cargo.toml

@@ -1,72 +0,0 @@
-[package]
-name = "viz"
-version = "0.1.0"
-edition = "2021"
-authors = ["Fangdun Tsai <[email protected]>"]
-
-[[bin]]
-name = "viz"
-path = "src/main.rs"
-
-[[bin]]
-name = "viz-pg"
-path = "src/main_pg.rs"
-required-features = ["tokio-postgres", "yarte"]
-
-[[bin]]
-name = "viz-sqlx"
-path = "src/main_sqlx.rs"
-required-features = ["sqlx", "markup", "v_htmlescape"]
-
-[[bin]]
-name = "viz-diesel"
-path = "src/main_diesel.rs"
-required-features = ["diesel", "diesel-async", "sailfish"]
-
-[dependencies]
-viz = "0.10"
-hyper = "1.0"
-hyper-util = "0.1"
-http-body-util = "0.1"
-atoi = "2.0"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1"
-mime = "0.3"
-rand = { version = "0.9", features = ["small_rng"] }
-thiserror = "2.0"
-futures-util = "0.3"
-socket2 = { version = "0.6.0", features = ["all"] }
-num_cpus = "1.16.0"
-
-[target.'cfg(not(unix))'.dependencies]
-nanorand = { version = "0.8" }
-
-[target.'cfg(unix)'.dependencies]
-nanorand = { version = "0.8", features = ["getrandom"] }
-
-tokio = { version = "1", features = ["full"] }
-tokio-postgres = { version = "0.7", optional = true }
-sqlx = { version = "0.8", features = [
-  "postgres",
-  "macros",
-  "runtime-tokio",
-  "tls-native-tls",
-], optional = true }
-diesel = { version = "2.2", default-features = false, features = [
-  "i-implement-a-third-party-backend-and-opt-into-breaking-changes",
-], optional = true }
-diesel-async = { version = "0.6", default-features = false, features = [
-  "postgres",
-  "bb8",
-], optional = true }
-
-yarte = { version = "0.15", features = ["bytes-buf", "json"], optional = true }
-markup = { version = "0.15", optional = true }
-v_htmlescape = { version = "0.15", optional = true }
-sailfish = { version = "0.10", optional = true }
-
-[profile.release]
-lto = true
-codegen-units = 1
-strip = true
-opt-level = 3

frameworks/Rust/viz/benchmark_config.json

@@ -1,89 +0,0 @@
-{
-  "framework": "viz",
-  "tests": [
-    {
-      "default": {
-        "json_url": "/json",
-        "plaintext_url": "/plaintext",
-        "port": 8080,
-        "approach": "Realistic",
-        "classification": "Platform",
-        "database": "none",
-        "framework": "Viz",
-        "language": "Rust",
-        "flavor": "None",
-        "orm": "Raw",
-        "platform": "Rust",
-        "webserver": "Hyper",
-        "os": "Linux",
-        "database_os": "Linux",
-        "display_name": "Viz",
-        "notes": "",
-        "versus": "None"
-      },
-      "pg": {
-        "db_url": "/db",
-        "fortune_url": "/fortunes",
-        "query_url": "/queries?q=",
-        "update_url": "/updates?q=",
-        "port": 8080,
-        "approach": "Realistic",
-        "classification": "Fullstack",
-        "database": "postgres",
-        "framework": "Viz",
-        "language": "Rust",
-        "flavor": "None",
-        "orm": "Raw",
-        "platform": "Rust",
-        "webserver": "Hyper",
-        "os": "Linux",
-        "database_os": "Linux",
-        "display_name": "Viz [Postgresql]",
-        "notes": "",
-        "versus": "None"
-      },
-      "sqlx": {
-        "db_url": "/db",
-        "fortune_url": "/fortunes",
-        "query_url": "/queries?q=",
-        "update_url": "/updates?q=",
-        "port": 8080,
-        "approach": "Realistic",
-        "classification": "Fullstack",
-        "database": "postgres",
-        "framework": "Viz",
-        "language": "Rust",
-        "flavor": "None",
-        "orm": "Raw",
-        "platform": "Rust",
-        "webserver": "Hyper",
-        "os": "Linux",
-        "database_os": "Linux",
-        "display_name": "Viz [Postgresql - SQLx]",
-        "notes": "",
-        "versus": "None"
-      },
-      "diesel": {
-        "db_url": "/db",
-        "fortune_url": "/fortunes",
-        "query_url": "/queries?q=",
-        "update_url": "/updates?q=",
-        "port": 8080,
-        "approach": "Realistic",
-        "classification": "Fullstack",
-        "database": "postgres",
-        "framework": "Viz",
-        "language": "Rust",
-        "flavor": "None",
-        "orm": "Full",
-        "platform": "Rust",
-        "webserver": "Hyper",
-        "os": "Linux",
-        "database_os": "Linux",
-        "display_name": "Viz [Postgresql - Diesel]",
-        "notes": "",
-        "versus": "None"
-      }
-    }
-  ]
-}

frameworks/Rust/viz/config.toml

@@ -1,60 +0,0 @@
-[framework]
-name = "viz"
-
-[main]
-urls.plaintext = "/plaintext"
-urls.json = "/json"
-approach = "Realistic"
-classification = "Micro"
-database = "Postgres"
-database_os = "Linux"
-os = "Linux"
-orm = "Raw"
-platform = "None"
-webserver = "viz"
-versus = ""
-
-[pg]
-urls.db = "/db"
-urls.query = "/queries?q="
-urls.update = "/updates?q="
-urls.fortune = "/fortunes"
-approach = "Realistic"
-classification = "Fullstack"
-database = "Postgres"
-database_os = "Linux"
-os = "Linux"
-orm = "Raw"
-platform = "None"
-webserver = "viz"
-versus = ""
-
-[sqlx]
-urls.db = "/db"
-urls.query = "/queries?q="
-urls.update = "/updates?q="
-urls.fortune = "/fortunes"
-approach = "Realistic"
-classification = "Fullstack"
-database = "Postgres"
-database_os = "Linux"
-os = "Linux"
-orm = "Raw"
-platform = "None"
-webserver = "viz"
-versus = ""
-
-[diesel]
-urls.db = "/db"
-urls.query = "/queries?q="
-urls.update = "/updates?q="
-urls.fortune = "/fortunes"
-approach = "Realistic"
-classification = "Fullstack"
-database = "Postgres"
-database_os = "Linux"
-os = "Linux"
-orm = "Full"
-platform = "None"
-webserver = "viz"
-versus = ""

frameworks/Rust/viz/src/db_diesel.rs

@@ -1,120 +0,0 @@
-use diesel::prelude::*;
-use diesel_async::{
-    pooled_connection::bb8::{Pool, RunError},
-    AsyncPgConnection, RunQueryDsl,
-};
-use nanorand::{Rng, WyRand};
-use sailfish::{RenderError, TemplateOnce};
-use viz::{Error, IntoResponse, Response, StatusCode};
-
-use crate::models_diesel::*;
-use crate::schema::*;
-use crate::RANGE;
-
-/// Postgres Error
-#[derive(Debug, thiserror::Error)]
-pub enum PgError {
-    #[error("missing pool")]
-    Missing,
-    #[error(transparent)]
-    DieselError(#[from] diesel::result::Error),
-    #[error(transparent)]
-    PoolError(#[from] RunError),
-    #[error(transparent)]
-    RenderError(#[from] RenderError),
-}
-
-impl From<PgError> for Error {
-    fn from(e: PgError) -> Self {
-        Error::Responder(e.into_response())
-    }
-}
-
-impl IntoResponse for PgError {
-    fn into_response(self) -> Response {
-        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
-    }
-}
-
-async fn _get_world(conn: &mut AsyncPgConnection, id: i32) -> Result<World, PgError> {
-    let world = world::table.find(id).first(conn).await?;
-    Ok(world)
-}
-
-pub async fn get_world(
-    pool: Pool<AsyncPgConnection>,
-    id: i32,
-) -> Result<World, PgError> {
-    let mut conn = pool.get().await?;
-    _get_world(&mut conn, id).await
-}
-
-pub async fn get_worlds(
-    pool: Pool<AsyncPgConnection>,
-    mut rng: WyRand,
-    count: u16,
-) -> Result<Vec<World>, PgError> {
-    let mut conn = pool.get().await?;
-
-    let mut worlds = Vec::<World>::with_capacity(count as usize);
-
-    for _ in 0..count {
-        let id = rng.generate_range(RANGE);
-        let w = _get_world(&mut conn, id).await?;
-        worlds.push(w);
-    }
-
-    Ok(worlds)
-}
-
-pub async fn update_worlds(
-    pool: Pool<AsyncPgConnection>,
-    mut rng: WyRand,
-    count: u16,
-) -> Result<Vec<World>, PgError> {
-    let mut conn = pool.get().await?;
-
-    let mut worlds = Vec::<World>::with_capacity(count as usize);
-
-    for _ in 0..count {
-        let id = rng.generate_range(RANGE);
-        let rid = rng.generate_range(RANGE);
-        let mut w = _get_world(&mut conn, id).await?;
-        w.randomnumber = rid;
-        worlds.push(w);
-    }
-
-    worlds.sort_by_key(|w| w.id);
-
-    conn.build_transaction()
-        .run(move |conn| {
-            Box::pin(async move {
-                for w in &worlds {
-                    diesel::update(world::table)
-                        .filter(world::id.eq(w.id))
-                        .set(world::randomnumber.eq(w.randomnumber))
-                        .execute(conn)
-                        .await?;
-                }
-
-                Ok::<_, PgError>(worlds)
-            })
-        })
-        .await
-}
-
-pub async fn tell_fortune(pool: Pool<AsyncPgConnection>) -> Result<String, PgError> {
-    let mut conn = pool.get().await?;
-
-    let mut items = fortune::table.load::<Fortune>(&mut conn).await?;
-
-    items.push(Fortune {
-        id: 0,
-        message: "Additional fortune added at request time.".to_string(),
-    });
-    items.sort_by(|it, next| it.message.cmp(&next.message));
-
-    let html = Fortunes::new(items).render_once()?;
-
-    Ok(html)
-}

frameworks/Rust/viz/src/db_sqlx.rs

@@ -1,119 +0,0 @@
-use nanorand::{Rng, WyRand};
-
-pub use sqlx::{
-    pool::PoolConnection,
-    postgres::{PgArguments, PgPoolOptions, PgRow},
-    Arguments, PgPool, Postgres, Row,
-};
-
-use viz::{Error, FromRequest, IntoResponse, Request, RequestExt, Response, StatusCode};
-
-use crate::models_sqlx::*;
-use crate::utils::get_query_param;
-use crate::RANGE;
-
-pub struct DatabaseConnection(pub PoolConnection<Postgres>);
-
-impl FromRequest for DatabaseConnection {
-    type Error = PgError;
-
-    async fn extract(req: &mut Request) -> Result<Self, Self::Error> {
-        req.state::<PgPool>()
-            .ok_or(PgError(sqlx::Error::Io(std::io::Error::from(
-                std::io::ErrorKind::NotConnected,
-            ))))?
-            .acquire()
-            .await
-            .map(Self)
-            .map_err(PgError)
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error(transparent)]
-pub struct PgError(#[from] pub sqlx::Error);
-
-impl From<PgError> for Error {
-    fn from(e: PgError) -> Self {
-        Error::Responder(e.into_response())
-    }
-}
-
-impl IntoResponse for PgError {
-    fn into_response(self) -> Response {
-        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
-    }
-}
-
-pub struct Counter(pub u16);
-
-impl FromRequest for Counter {
-    type Error = Error;
-
-    async fn extract(req: &mut Request) -> Result<Self, Self::Error> {
-        Ok(Counter(get_query_param(req.query_string())))
-    }
-}
-
-pub async fn get_world(
-    conn: &mut PoolConnection<Postgres>,
-    id: i32,
-) -> Result<World, PgError> {
-    let mut args = PgArguments::default();
-    let _ = args.add(id);
-
-    let world =
-        sqlx::query_as_with("SELECT id, randomnumber FROM World WHERE id = $1", args)
-            .fetch_one(&mut **conn)
-            .await?;
-    Ok(world)
-}
-
-pub async fn update_worlds(
-    mut conn: PoolConnection<Postgres>,
-    mut rng: WyRand,
-    count: u16,
-) -> Result<Vec<World>, PgError> {
-    let mut worlds = Vec::<World>::with_capacity(count as usize);
-
-    for _ in 0..count {
-        let id = rng.generate_range(RANGE);
-        let rid = rng.generate_range(RANGE);
-        let mut w = get_world(&mut conn, id).await?;
-        w.randomnumber = rid;
-        worlds.push(w);
-    }
-
-    for w in &worlds {
-        let mut args = PgArguments::default();
-        let _ = args.add(w.randomnumber);
-        let _ = args.add(w.id);
-
-        sqlx::query_with("UPDATE World SET randomNumber = $1 WHERE id = $2", args)
-            .execute(&mut *conn)
-            .await?;
-    }
-
-    Ok(worlds)
-}
-
-pub async fn get_fortunes(
-    mut conn: PoolConnection<Postgres>,
-) -> Result<Vec<Fortune>, PgError> {
-    let mut items = sqlx::query("SELECT * FROM Fortune")
-        .map(|row: PgRow| Fortune {
-            id: row.get(0),
-            message: row.get(1),
-        })
-        .fetch_all(&mut *conn)
-        .await?;
-
-    items.push(Fortune {
-        id: 0,
-        message: "Additional fortune added at request time.".to_string(),
-    });
-
-    items.sort_by(|it, next| it.message.cmp(&next.message));
-
-    Ok(items)
-}

frameworks/Rust/viz/src/main_diesel.rs

@@ -1,104 +0,0 @@
-#[macro_use]
-extern crate diesel;
-
-use std::thread::available_parallelism;
-
-use diesel_async::{
-    pooled_connection::{bb8::Pool, AsyncDieselConnectionManager},
-    AsyncPgConnection,
-};
-use nanorand::{Rng, WyRand};
-use viz::{
-    header::{HeaderValue, SERVER},
-    types::State,
-    Request, RequestExt, Response, ResponseExt, Result, Router,
-};
-
-mod db_diesel;
-pub mod models_diesel;
-pub mod schema;
-mod server;
-mod utils;
-
-use db_diesel::*;
-use utils::RANGE;
-
-const DB_URL: &str =
-    "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
-
-async fn db(req: Request) -> Result<Response> {
-    let mut rng = req.state::<WyRand>().unwrap();
-    let pool = req.state::<Pool<AsyncPgConnection>>().unwrap();
-
-    let random_id = rng.generate_range(RANGE);
-
-    let world = get_world(pool, random_id).await?;
-
-    let mut res = Response::json(world)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn fortunes(req: Request) -> Result<Response> {
-    let pool = req.state::<Pool<AsyncPgConnection>>().unwrap();
-
-    let fortunes = tell_fortune(pool).await?;
-
-    let mut res = Response::html(fortunes);
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn queries(req: Request) -> Result<Response> {
-    let rng = req.state::<WyRand>().unwrap();
-    let pool = req.state::<Pool<AsyncPgConnection>>().unwrap();
-    let count = utils::get_query_param(req.query_string());
-
-    let worlds = get_worlds(pool, rng, count).await?;
-
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn updates(req: Request) -> Result<Response> {
-    let rng = req.state::<WyRand>().unwrap();
-    let pool = req.state::<Pool<AsyncPgConnection>>().unwrap();
-    let count = utils::get_query_param(req.query_string());
-
-    let worlds = update_worlds(pool, rng, count).await?;
-
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn app() {
-    let max = available_parallelism().map(|n| n.get()).unwrap_or(16) as u32;
-
-    let pool = Pool::<AsyncPgConnection>::builder()
-        .max_size(max)
-        .min_idle(Some(max))
-        .idle_timeout(None)
-        .build_unchecked(AsyncDieselConnectionManager::new(DB_URL));
-
-    let rng = WyRand::new();
-
-    let app = Router::new()
-        .get("/db", db)
-        .get("/fortunes", fortunes)
-        .get("/queries", queries)
-        .get("/updates", updates)
-        .with(State::new(pool))
-        .with(State::new(rng));
-
-    server::serve(app).await.unwrap()
-}
-
-fn main() {
-    server::run(app)
-}

frameworks/Rust/viz/src/main_sqlx.rs

@@ -1,129 +0,0 @@
-use std::thread::available_parallelism;
-
-use nanorand::{Rng, WyRand};
-use viz::{
-    header::{HeaderValue, SERVER},
-    types::State,
-    BytesMut, Error, Request, RequestExt, Response, ResponseExt, Result, Router,
-};
-
-mod db_sqlx;
-mod models_sqlx;
-mod server;
-mod utils;
-
-use db_sqlx::*;
-use models_sqlx::{Fortune, World};
-use utils::RANGE;
-
-const DB_URL: &str =
-    "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
-
-async fn db(mut req: Request) -> Result<Response> {
-    let (State(mut rng), DatabaseConnection(mut conn)) =
-        req.extract::<(State<WyRand>, DatabaseConnection)>().await?;
-
-    let random_id = rng.generate_range(RANGE);
-
-    let world = get_world(&mut conn, random_id).await?;
-
-    let mut res = Response::json(world)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn fortunes(mut req: Request) -> Result<Response> {
-    let DatabaseConnection(conn) = req.extract::<DatabaseConnection>().await?;
-
-    let items = get_fortunes(conn).await?;
-
-    let mut buf = BytesMut::with_capacity(2048);
-    buf.extend(FortunesTemplate { items }.to_string().as_bytes());
-
-    let mut res = Response::html(buf.freeze());
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn queries(mut req: Request) -> Result<Response> {
-    let (Counter(count), State(mut rng), DatabaseConnection(mut conn)) = req
-        .extract::<(Counter, State<WyRand>, DatabaseConnection)>()
-        .await?;
-
-    let mut worlds = Vec::<World>::with_capacity(count as usize);
-
-    for _ in 0..count {
-        let id = rng.generate_range(RANGE);
-        let w = get_world(&mut conn, id).await?;
-        worlds.push(w);
-    }
-
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn updates(mut req: Request) -> Result<Response> {
-    let (Counter(count), State(rng), DatabaseConnection(conn)) = req
-        .extract::<(Counter, State<WyRand>, DatabaseConnection)>()
-        .await?;
-
-    let worlds = update_worlds(conn, rng, count).await?;
-
-    let mut res = Response::json(worlds)?;
-    res.headers_mut()
-        .insert(SERVER, HeaderValue::from_static("Viz"));
-    Ok(res)
-}
-
-async fn app() -> Result<()> {
-    let max = available_parallelism().map(|n| n.get()).unwrap_or(16) as u32;
-
-    let pool = PgPoolOptions::new()
-        .max_connections(max)
-        .min_connections(max)
-        .connect(DB_URL)
-        .await
-        .map_err(PgError)?;
-
-    let rng = WyRand::new();
-
-    let app = Router::new()
-        .get("/db", db)
-        .get("/fortunes", fortunes)
-        .get("/queries", queries)
-        .get("/updates", updates)
-        .with(State::new(pool))
-        .with(State::new(rng));
-
-    server::serve(app).await.map_err(Error::Boxed)
-}
-
-fn main() {
-    server::run(app)
-}
-
-markup::define! {
-    FortunesTemplate(items: Vec<Fortune>) {
-        {markup::doctype()}
-        html {
-            head {
-                title { "Fortunes" }
-            }
-            body {
-                table {
-                    tr { th { "id" } th { "message" } }
-                    @for item in items {
-                        tr {
-                            td { {item.id} }
-                            td { {markup::raw(v_htmlescape::escape(&item.message).to_string())} }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

frameworks/Rust/viz/src/models_diesel.rs

@@ -1,28 +0,0 @@
-use diesel::Queryable;
-use sailfish::TemplateOnce;
-use serde::Serialize;
-
-#[derive(Serialize, Queryable, Debug)]
-pub struct World {
-    pub id: i32,
-    pub randomnumber: i32,
-}
-
-#[derive(Serialize, Queryable, Debug)]
-pub struct Fortune {
-    pub id: i32,
-    pub message: String,
-}
-
-#[derive(TemplateOnce)]
-#[template(path = "fortune.stpl", rm_whitespace = true)]
-pub struct Fortunes {
-    items: Vec<Fortune>,
-}
-
-impl Fortunes {
-    #[inline]
-    pub fn new(items: Vec<Fortune>) -> Self {
-        Self { items }
-    }
-}

frameworks/Rust/viz/src/models_sqlx.rs

@@ -1,14 +0,0 @@
-use serde::{Deserialize, Serialize};
-use sqlx::FromRow;
-
-#[derive(Debug, PartialEq, Deserialize, Serialize, FromRow)]
-pub struct World {
-    pub id: i32,
-    pub randomnumber: i32,
-}
-
-#[derive(Debug, PartialEq, Deserialize, Serialize, FromRow)]
-pub struct Fortune {
-    pub id: i32,
-    pub message: String,
-}

frameworks/Rust/viz/src/schema.rs

@@ -1,13 +0,0 @@
-table! {
-    world (id) {
-        id -> Integer,
-        randomnumber -> Integer,
-    }
-}
-
-table! {
-    fortune (id) {
-        id -> Integer,
-        message -> Text,
-    }
-}

frameworks/Rust/viz/viz-diesel.dockerfile

@@ -1,11 +0,0 @@
-FROM rust:1.89
-
-ADD ./ /viz
-WORKDIR /viz
-
-RUN cargo clean
-RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin viz-diesel --features="diesel,diesel-async,sailfish"
-
-EXPOSE 8080
-
-CMD ./target/release/viz-diesel

frameworks/Rust/viz/viz-pg.dockerfile

@@ -1,11 +0,0 @@
-FROM rust:1.89
-
-ADD ./ /viz
-WORKDIR /viz
-
-RUN cargo clean
-RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin viz-pg --features="tokio-postgres,yarte"
-
-EXPOSE 8080
-
-CMD ./target/release/viz-pg

frameworks/Rust/viz/viz-sqlx.dockerfile

@@ -1,11 +0,0 @@
-FROM rust:1.89
-
-ADD ./ /viz
-WORKDIR /viz
-
-RUN cargo clean
-RUN RUSTFLAGS="-C target-cpu=native" cargo build --release --bin viz-sqlx --features="sqlx,markup,v_htmlescape"
-
-EXPOSE 8080
-
-CMD ./target/release/viz-sqlx