Unverified Commit a13fabe6 authored by Jérémie Drouet's avatar Jérémie Drouet Committed by GitHub
Browse files

refacto(react-rust-postgres): replace rocket by actix-web (#153)


Signed-off-by: default avatarJérémie Drouet <jeremie.drouet@gmail.com>
parent 0ae9d4ce
......@@ -7,17 +7,11 @@ edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
diesel_migrations = "1.4.0"
rocket = "0.4.4"
actix-web = "4.0.0-beta.8"
deadpool-postgres = "0.9.0"
env_logger = "^0.8"
log = "^0.4"
serde = "1.0"
serde_json = "1.0"
serde_derive = "1.0"
[dependencies.diesel]
version = "1.0.0"
features = ["postgres"]
[dependencies.rocket_contrib]
version = "0.4.4"
default-features = false
features = ["json", "diesel_postgres_pool"]
tokio-postgres = "^0.7"
tokio-postgres-migration = "^0.1"
FROM jdrouet/rust-nightly:buster-slim AS base
RUN apt-get update \
&& apt-get install -y libpq-dev \
&& rm -rf /var/lib/apt/lists/*
FROM rust:buster AS base
ENV USER=root
ENV ROCKET_ADDRESS=0.0.0.0
......
# For documentation on how to configure this file,
# see diesel.rs/guides/configuring-diesel-cli
[print_schema]
file = "src/schema.rs"
-- This file was automatically created by Diesel to setup helper functions
-- and other internal bookkeeping. This file is safe to edit, any future
-- changes will be added to existing projects as new migrations.
DROP FUNCTION IF EXISTS diesel_manage_updated_at(_tbl regclass);
DROP FUNCTION IF EXISTS diesel_set_updated_at();
-- This file was automatically created by Diesel to setup helper functions
-- and other internal bookkeeping. This file is safe to edit, any future
-- changes will be added to existing projects as new migrations.
-- Sets up a trigger for the given table to automatically set a column called
-- `updated_at` whenever the row is modified (unless `updated_at` was included
-- in the modified columns)
--
-- # Example
--
-- ```sql
-- CREATE TABLE users (id SERIAL PRIMARY KEY, updated_at TIMESTAMP NOT NULL DEFAULT NOW());
--
-- SELECT diesel_manage_updated_at('users');
-- ```
CREATE OR REPLACE FUNCTION diesel_manage_updated_at(_tbl regclass) RETURNS VOID AS $$
BEGIN
EXECUTE format('CREATE TRIGGER set_updated_at BEFORE UPDATE ON %s
FOR EACH ROW EXECUTE PROCEDURE diesel_set_updated_at()', _tbl);
END;
$$ LANGUAGE plpgsql;
CREATE OR REPLACE FUNCTION diesel_set_updated_at() RETURNS trigger AS $$
BEGIN
IF (
NEW IS DISTINCT FROM OLD AND
NEW.updated_at IS NOT DISTINCT FROM OLD.updated_at
) THEN
NEW.updated_at := current_timestamp;
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
# Backend
This backend is made with Rust using [Rocket](https://rocket.rs/) as a web server and [Diesel](https://diesel.rs/) as an ORM.
This backend is made with Rust using [actix-web](https://actix.rs/) as a web server and [deadpool-postgres](https://crates.io/crates/deadpool-postgres) as a connection manager.
#![feature(proc_macro_hygiene, decl_macro)]
use actix_web::{get, web, App, HttpResponse, HttpServer};
use deadpool_postgres::Pool;
#[macro_use]
extern crate diesel;
#[macro_use]
extern crate diesel_migrations;
#[macro_use]
extern crate rocket;
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate rocket_contrib;
mod schema;
mod postgres;
mod user;
use rocket::config::{Config, Environment, Value};
use rocket::fairing::AdHoc;
use rocket_contrib::json::Json;
use std::collections::HashMap;
use std::env;
// This macro from `diesel_migrations` defines an `embedded_migrations` module
// containing a function named `run`. This allows the example to be run and
// tested without any outside setup of the database.
embed_migrations!();
#[database("my_db")]
struct MyDBConn(diesel::PgConnection);
#[derive(Serialize)]
struct HelloMessage {
message: String,
}
#[get("/")]
fn index(conn: MyDBConn) -> Json<HelloMessage> {
let result = match user::User::all(&*conn) {
Ok(res) => res.len(),
Err(_) => 0,
#[get("/users")]
async fn list_users(pool: web::Data<Pool>) -> HttpResponse {
let client = match pool.get().await {
Ok(client) => client,
Err(err) => {
log::debug!("unable to get postgres client: {:?}", err);
return HttpResponse::InternalServerError().json("unable to get postgres client");
}
};
Json(HelloMessage {
message: format!("Hello with {} users", result),
})
match user::User::all(&**client).await {
Ok(list) => HttpResponse::Ok().json(list),
Err(err) => {
log::debug!("unable to fetch users: {:?}", err);
return HttpResponse::InternalServerError().json("unable to fetch users");
}
}
}
fn get_config() -> Config {
let mut database_config = HashMap::new();
let mut databases = HashMap::new();
let env_address = env::var("ROCKET_ADDRESS")
.or::<String>(Ok(String::from("localhost")))
.unwrap();
let env_mode = env::var("ROCKET_ENV")
.or(Ok(String::from("development")))
.and_then(|value| value.parse::<Environment>())
.unwrap();
let database_url = match env::var("DATABASE_URL") {
Ok(value) => value,
Err(_) => String::from("postgres://localhost/postgres"),
};
database_config.insert("url", Value::from(database_url));
databases.insert("my_db", Value::from(database_config));
let config = Config::build(env_mode)
.address(env_address)
.extra("databases", databases)
.finalize()
.unwrap();
config
fn address() -> String {
std::env::var("ADDRESS").unwrap_or_else(|_| "127.0.0.1:8000".into())
}
fn run_db_migrations(r: rocket::Rocket) -> Result<rocket::Rocket, rocket::Rocket> {
let conn = MyDBConn::get_one(&r).expect("database connection");
match embedded_migrations::run(&*conn) {
Ok(()) => Ok(r),
Err(e) => {
println!("Failed to run database migrations: {:?}", e);
Err(r)
}
}
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
env_logger::init();
fn main() {
let config = get_config();
rocket::custom(config)
.attach(MyDBConn::fairing())
.attach(AdHoc::on_attach("Database Migrations", run_db_migrations))
.mount("/", routes![index])
.launch();
let pg_pool = postgres::create_pool();
postgres::migrate_up(&pg_pool).await;
let address = address();
HttpServer::new(move || {
App::new()
.app_data(web::Data::new(pg_pool.clone()))
.service(list_users)
})
.bind(&address)?
.run()
.await
}
use deadpool_postgres::{Config, Pool};
use tokio_postgres::NoTls;
use tokio_postgres_migration::Migration;
const SCRIPTS_UP: [(&str, &str); 1] = [(
"0001_create-users",
include_str!("../migrations/0001_create-users_up.sql"),
)];
fn create_config() -> Config {
let mut cfg = Config::new();
if let Ok(host) = std::env::var("PG_HOST") {
cfg.host = Some(host);
}
if let Ok(dbname) = std::env::var("PG_DBNAME") {
cfg.dbname = Some(dbname);
}
if let Ok(user) = std::env::var("PG_USER") {
cfg.user = Some(user);
}
if let Ok(password) = std::env::var("PG_PASSWORD") {
cfg.password = Some(password);
}
cfg
}
pub fn create_pool() -> Pool {
create_config()
.create_pool(NoTls)
.expect("couldn't create postgres pool")
}
pub async fn migrate_up(pool: &Pool) {
let mut client = pool.get().await.expect("couldn't get postgres client");
let migration = Migration::new("migrations".to_string());
migration
.up(&mut **client, &SCRIPTS_UP)
.await
.expect("couldn't run migrations");
}
table! {
users (id) {
id -> Int4,
login -> Text,
}
}
#![allow(proc_macro_derive_resolution_fallback)]
use tokio_postgres::{Error, GenericClient, Row};
use diesel;
use diesel::prelude::*;
use super::schema::users;
#[derive(Queryable, AsChangeset, Serialize, Deserialize)]
#[table_name = "users"]
#[derive(Debug, serde::Serialize)]
pub struct User {
pub id: i32,
pub login: String,
}
impl From<Row> for User {
fn from(row: Row) -> Self {
Self {
id: row.get(0),
login: row.get(1),
}
}
}
impl User {
pub fn all(connection: &PgConnection) -> QueryResult<Vec<User>> {
users::table.load::<User>(&*connection)
pub async fn all<C: GenericClient>(client: &C) -> Result<Vec<User>, Error> {
let stmt = client.prepare("SELECT id, login FROM users").await?;
let rows = client.query(&stmt, &[]).await?;
Ok(rows.into_iter().map(User::from).collect())
}
}
......@@ -10,12 +10,18 @@ services:
- 3000:3000
volumes:
- ./frontend/src:/code/src:ro
backend:
build:
context: backend
target: development
environment:
- DATABASE_URL=postgres://postgres:mysecretpassword@db/postgres
- ADDRESS=0.0.0.0:8000
- RUST_LOG=debug
- PG_DBNAME=postgres
- PG_HOST=db
- PG_USER=postgres
- PG_PASSWORD=mysecretpassword
networks:
- client-side
- server-side
......@@ -24,6 +30,7 @@ services:
- backend-cache:/code/target
depends_on:
- db
db:
image: postgres:12-alpine
restart: always
......@@ -35,9 +42,11 @@ services:
- 5432:5432
volumes:
- db-data:/var/lib/postgresql/data
networks:
client-side: {}
server-side: {}
volumes:
backend-cache: {}
db-data: {}
......@@ -5,9 +5,9 @@ import "./App.css";
function App() {
const [message, setMessage] = useState();
useEffect(() => {
fetch("/api/")
.then(res => res.json())
.then(res => setMessage(res.message))
fetch("/api/users")
.then((res) => res.json())
.then((res) => setMessage(res.message))
.catch(console.error);
}, [setMessage]);
return (
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment