944 lines
23 KiB
Org Mode
944 lines
23 KiB
Org Mode
#+STARTUP: beamer
|
|
#+OPTIONS: ':nil *:t -:t ::t <:t H:3 \n:nil ^:t arch:headline
|
|
#+OPTIONS: author:t broken-links:nil c:nil creator:nil
|
|
#+OPTIONS: d:(not "LOGBOOK") date:t e:t email:nil f:t inline:t num:t
|
|
#+OPTIONS: p:nil pri:nil prop:nil stat:t tags:t tasks:t tex:t
|
|
#+OPTIONS: timestamp:t title:t toc:t todo:t |:t
|
|
#+OPTIONS: ^:nil
|
|
#+TITLE: Rust, Rocket and Diesel
|
|
#+SUBTITLE: Web apps with Rust
|
|
#+DESCRIPTION: An introduction to Rust, Rocket and Diesel.
|
|
#+KEYWORDS: rust rocket diesel
|
|
#+AUTHOR: \href{mailto:finga@onders.org}{finga}
|
|
#+EMAIL: finga@onders.org
|
|
#+LANGUAGE: en
|
|
#+SELECT_TAGS: export
|
|
#+EXCLUDE_TAGS: noexport
|
|
#+CREATOR: Emacs 26.1 (Org mode 9.1.9)
|
|
|
|
#+OPTIONS: H:2
|
|
#+LATEX_CLASS: beamer
|
|
#+LATEX_CLASS_OPTIONS: [aspectratio=1610]
|
|
# #+LATEX_HEADER: \hypersetup{colorlinks=true,linkcolor=gray}
|
|
#+LATEX_HEADER: \hypersetup{colorlinks=true,linkcolor=black,urlcolor=gray}
|
|
# #+LATEX_HEADER: \usepackage{listings, listings-rust}
|
|
#+COLUMNS: %45ITEM %10BEAMER_env(Env) %10BEAMER_act(Act) %4BEAMER_col(Col) %8BEAMER_opt(Opt)
|
|
#+BEAMER_THEME: Frankfurt
|
|
#+BEAMER_COLOR_THEME: seagull
|
|
#+BEAMER_FONT_THEME:
|
|
#+BEAMER_INNER_THEME:
|
|
#+BEAMER_OUTER_THEME:
|
|
#+BEAMER_HEADER: \institute[INST]{\href{https://cccsbg.at}{cccsbg}}
|
|
|
|
* Rust
|
|
|
|
** What is Rust?
|
|
#+BEGIN_CENTER
|
|
#+LaTeX:\includegraphics[width = 0.65\textwidth]{img/Bruine_roest_op_tarwe_(Puccinia_recondita_f.sp._tritici_on_Triticum_aestivum).jpg}
|
|
#+END_CENTER
|
|
|
|
*** Rust, the language
|
|
- About 10 years young (2010)
|
|
- Memory safe without gcing, optional ref counting
|
|
- Ownership, lifetimes, traits, functional paradigms
|
|
- Variables are immutable by default and can be shadowed
|
|
- Performance of idiomatic Rust is comparable to the performance
|
|
of idiomatic cpp
|
|
|
|
** How to install
|
|
|
|
*** Install Rust
|
|
#+BEGIN_SRC sh
|
|
$ curl --proto '=https' --tlsv1.2 -sSf \
|
|
https://sh.rustup.rs | sh
|
|
#+END_SRC
|
|
|
|
*** Install nightly Rust (needed for Rocket)
|
|
#+BEGIN_SRC sh
|
|
$ rustup toolchain install nightly
|
|
#+END_SRC
|
|
|
|
*** Install rustfmt (linter and code formatter)
|
|
#+BEGIN_SRC sh
|
|
$ rustup component add rustfmt
|
|
#+END_SRC
|
|
|
|
*** Install clippy (static code analysis)
|
|
#+BEGIN_SRC sh
|
|
$ rustup component add clippy
|
|
#+END_SRC
|
|
|
|
** Where to find more information?
|
|
|
|
*** Docs...
|
|
- [[https://doc.rust-lang.org/book/][The Rust Book]] (~$ rustup docs --book~)
|
|
- [[https://doc.rust-lang.org/rust-by-example/][Rust by Example]] (~$ rustup docs --rust-by-example~)
|
|
- [[https://doc.rust-lang.org/std/][The Rust Standard Library]] (~$ rustup docs --std~)
|
|
- Use '~$ rustup help docs~' to get an overview
|
|
- [[https://cheats.rs][cheats.rs]]
|
|
- [[https://programming-idioms.org/cheatsheet/Rust][programming-idioms.org]]
|
|
- [[https://crates.io][crates.io]]/[[https://lib.rs][lib.rs]]
|
|
|
|
*** Chat (Discord)
|
|
- [[https://discord.gg/rust-lang][The Rust Programming Language]]
|
|
- [[https://discord.com/invite/tcbkpyQ][The Rust Programming Language Community Server]]
|
|
|
|
** Hello, World!
|
|
Executing ~`cargo new foobar`~ creates a new project...
|
|
|
|
*** foobar/Cargo.toml
|
|
#+BEGIN_SRC toml
|
|
[package]
|
|
name = "foo"
|
|
version = "0.1.0"
|
|
authors = ["finga <finga@onders.org>"]
|
|
edition = "2018"
|
|
#+END_SRC
|
|
\tiny
|
|
#+BEGIN_SRC toml
|
|
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
|
#+END_SRC
|
|
\normalsize
|
|
#+BEGIN_SRC toml
|
|
[dependencies]
|
|
#+END_SRC
|
|
|
|
*** foobar/src/main.rs
|
|
#+BEGIN_SRC rust
|
|
fn main() {
|
|
println!("Hello, world!");
|
|
}
|
|
#+END_SRC
|
|
|
|
** Mutability and shadowing
|
|
|
|
*** Immutable variable
|
|
#+BEGIN_SRC rust
|
|
let foo = 5;
|
|
#+END_SRC
|
|
|
|
*** Mutable variable
|
|
#+BEGIN_SRC rust
|
|
let mut bar = 5;
|
|
bar = 6;
|
|
#+END_SRC
|
|
|
|
*** Shadowing
|
|
#+BEGIN_SRC rust
|
|
let baz = 5;
|
|
let baz = baz + 3;
|
|
#+END_SRC
|
|
|
|
** Structs
|
|
|
|
*** Definition of a struct
|
|
#+BEGIN_SRC rust
|
|
struct Something {
|
|
id: usize,
|
|
item: String,
|
|
}
|
|
#+END_SRC
|
|
|
|
*** Instantiation of a struct
|
|
#+BEGIN_SRC rust
|
|
let something = Something {
|
|
id: 0,
|
|
item: String::from("an item"),
|
|
};
|
|
#+END_SRC
|
|
|
|
*** Access of a struct's field
|
|
#+BEGIN_SRC rust
|
|
something.item
|
|
#+END_SRC
|
|
|
|
** Tuple structs
|
|
|
|
*** Definition of a tuple struct
|
|
#+BEGIN_SRC rust
|
|
struct Box(usize, usize, usize);
|
|
#+END_SRC
|
|
|
|
*** Instantiation of a tuple struct
|
|
#+BEGIN_SRC rust
|
|
let first_box = Box(3, 5, 7);
|
|
#+END_SRC
|
|
|
|
*** Access of a tuple struct's field
|
|
#+BEGIN_SRC rust
|
|
first_box.0;
|
|
first_box.1;
|
|
first_box.2;
|
|
#+END_SRC
|
|
|
|
** Error related types
|
|
- Heavy use of ~Option<T>~ and ~Result<T, E>~
|
|
|
|
*** Option
|
|
#+BEGIN_SRC rust
|
|
pub enum Option<T> {
|
|
None,
|
|
Some(T),
|
|
}
|
|
#+END_SRC
|
|
|
|
*** Result
|
|
#+BEGIN_SRC rust
|
|
pub enum Result<T, E> {
|
|
Ok(T),
|
|
Err(E),
|
|
}
|
|
#+END_SRC
|
|
|
|
** Error handling
|
|
|
|
*** Unrecoverable errors \rightarrow panics
|
|
#+BEGIN_SRC rust
|
|
fn get_data() -> Data {
|
|
...
|
|
panic!("Cannot get data");
|
|
}
|
|
#+END_SRC
|
|
|
|
*** Recoverable error with anyhow
|
|
#+BEGIN_SRC rust
|
|
fn get_data() -> Result<Data> {
|
|
...
|
|
Ok(data) // return is only used for "early" returns
|
|
}
|
|
...
|
|
let data = get_data()?;
|
|
...
|
|
#+END_SRC
|
|
|
|
** ~match~ statements
|
|
- Must be exhaustive
|
|
- All match arms must return the same type!
|
|
- Can be used everywhere e.g. ~let foo = match ...~
|
|
- @@latex:{\color{red}@@All match arms must return the same type!!1!@@latex:}@@
|
|
|
|
*** Recoverable error with anyhow
|
|
#+BEGIN_SRC rust
|
|
match age {
|
|
0 => unreachable!("Too young to be a person"),
|
|
n @ 1..=12 => println!("Child of age {}", n),
|
|
n @ 13..=19 => println!("Teen of age {}", n),
|
|
n @ 20..=150 => println!("Person of age {}", n),
|
|
_ => unimplemented!("Nobody I know got that old"),
|
|
}
|
|
#+END_SRC
|
|
|
|
** ~if let~ statements
|
|
|
|
*** Sometimes an ~if let~ is nicer than a ~match~ or an ~if/else~ statement
|
|
#+BEGIN_SRC rust
|
|
if let Some(actual_age) = age {
|
|
println!("The age is {}", actual_age);
|
|
}
|
|
#+END_SRC
|
|
|
|
** Use functional language features
|
|
- ~vec![1, 2, 3].iter()~
|
|
- ~vec![1, 2, 3].iter().sum()~
|
|
- ~vec![1, 2, 3].iter().map(|x| x + 1).collect()~
|
|
- ~foo.into_iter().filter(|i| i.bar == 0).collect()~
|
|
- ~Iterator~ trait
|
|
|
|
** Tests
|
|
- Use ~assert!()~ family
|
|
- Unit tests
|
|
- Put them into a test module
|
|
- Annotate the test module with ~#[cfg(test)]~
|
|
- Annotate the tests with ~#[test]~
|
|
- Documentation testing
|
|
- Integration testing
|
|
- Integration tests are put into the ~src/tests/~ directory
|
|
|
|
** Docs
|
|
- Documentation comments: ~///~
|
|
- Markdown notation
|
|
- ~cargo doc~ runns ~rustdoc~ which generates html docs
|
|
- ~cargo doc --open~ runs ~rustdoc~ and opens the result in a browser
|
|
- ~rustdoc~ documentation: https://doc.rust-lang.org/beta/rustdoc/index.html
|
|
|
|
* Rocket
|
|
|
|
** What is Rocket?
|
|
#+BEGIN_QUOTE
|
|
Rocket is a web framework for Rust that makes it simple to write
|
|
fast, secure web applications without sacrificing flexibility,
|
|
usability, or type safety.
|
|
#+END_QUOTE
|
|
|
|
*** Features
|
|
|
|
**** Col left
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:END:
|
|
- Type Safe
|
|
- Extensible
|
|
- Templating
|
|
- (Secure) Cookies
|
|
|
|
**** Col right
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:END:
|
|
- Streams
|
|
- Testing (Unit tests)
|
|
- Typed URIs
|
|
- Single binary
|
|
|
|
** Create a new Rocket project
|
|
*** Create the crate
|
|
#+BEGIN_SRC sh
|
|
cargo init new_project
|
|
cd new_project
|
|
rustup override set nightly
|
|
cargo r
|
|
#+END_SRC
|
|
|
|
*** Add Rocket dependencies to ~Cargo.toml~
|
|
#+BEGIN_SRC toml
|
|
[dependencies]
|
|
rocket = "0.4"
|
|
#+END_SRC
|
|
|
|
** Hello Rocket
|
|
*** ~src/main.rs~
|
|
#+BEGIN_SRC rust
|
|
#![feature(decl_macro)]
|
|
|
|
use rocket::{get, routes};
|
|
|
|
#[get("/hello/<name>/<age>")]
|
|
fn hello(name: String, age: u8) -> String {
|
|
format!("Hello, {} year old named {}!", age, name)
|
|
}
|
|
|
|
fn main() {
|
|
rocket::ignite().mount("/", routes![hello]).launch();
|
|
}
|
|
#+END_SRC
|
|
|
|
** Receive data
|
|
*** Struct ~EmailForm~
|
|
#+BEGIN_SRC rust
|
|
#[derive(Debug, FromForm)]
|
|
struct EmailForm {
|
|
email: String,
|
|
}
|
|
#+END_SRC
|
|
|
|
*** Procedure using that form data
|
|
#+BEGIN_SRC rust
|
|
#[post("/reset", data = "<email>")]
|
|
fn reset_email(email: Form<EmailForm>) -> Flash<Redirect> {
|
|
...
|
|
Flash::success(
|
|
Redirect::to(uri!(reset)),
|
|
format!("Email was sent to {}", email.email),
|
|
)
|
|
}
|
|
#+END_SRC
|
|
|
|
** Flash messages
|
|
#+BEGIN_SRC rust
|
|
#[get("/reset")]
|
|
fn reset(flash: Option<FlashMessage>) -> String {
|
|
if let Some(ref msg) = flash { // `let ref x = y` is
|
|
msg.msg() // equivalent to `let x = &y`
|
|
} else {
|
|
format!("Hello, reset!");
|
|
}
|
|
}
|
|
#+END_SRC
|
|
|
|
** Templates
|
|
- Use the ~rocket_contrib~ crate!
|
|
*** ~templates/name.html.tera~
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.35
|
|
:BEAMER_env: block
|
|
:END:
|
|
#+BEGIN_SRC html
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
...
|
|
</head>
|
|
<body>
|
|
<p> Hello,
|
|
{{ name }}!</p>
|
|
</body>
|
|
</html>
|
|
#+END_SRC
|
|
|
|
*** ~src/main.rs~
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.60
|
|
:BEAMER_env: block
|
|
:END:
|
|
#+BEGIN_SRC rust
|
|
#[get("/hello/<name>")]
|
|
fn hello(name: String) -> Template {
|
|
let mut context = HashMap::new();
|
|
context.insert("name", name);
|
|
|
|
Template::render("name", &context)
|
|
}
|
|
...
|
|
rocket::ignite()
|
|
.mount(...)
|
|
.attach(Template::fairing())
|
|
.launch();
|
|
#+END_SRC
|
|
|
|
** Where to get further information?
|
|
|
|
*** Docs...
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- [[https://rocket.rs][rocket.rs]]
|
|
- [[https://rocket.rs/v0.4/guide/][Rocket Guide]]
|
|
- [[https://api.rocket.rs/v0.4/rocket/][Rocket API docs]]
|
|
- [[https://github.com/SergioBenitez/Rocket/tree/v0.4/examples][Examples]]
|
|
|
|
*** Chat
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- Matrix: [[https://chat.mozilla.org/#/room/%23rocket:mozilla.org][#rocket:mozilla.org]]
|
|
- IRC on Freenode: [[https://kiwiirc.com/client/chat.freenode.net/#rocket][#rocket]]
|
|
|
|
* Diesel
|
|
|
|
** ORM
|
|
Object-relational-mapping is a programming technique for converting
|
|
data between incompatible type systems using the paradigms of your
|
|
programming language.
|
|
|
|
*** Pros
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- Models are DRY (don't repeat yourself)
|
|
- Cleaner separation
|
|
- Prepared and sanitised queries
|
|
- Changes are versioned
|
|
|
|
*** Cons
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- Debugging can get more complicated (performance)
|
|
- No need to learn SQL
|
|
|
|
** Prerequisites ~diesel_cli~
|
|
|
|
*** Setup Diesel for default DBMS
|
|
#+BEGIN_SRC sh
|
|
$ sudo apt install libpq-dev libsqlite3-dev \
|
|
default-libmysqlclient-dev
|
|
$ cargo install diesel_cli
|
|
#+END_SRC
|
|
|
|
*** Setup Diesel for SQLite only
|
|
#+BEGIN_SRC sh
|
|
$ sudo apt install libsqlite3-dev
|
|
$ cargo install diesel_cli -no-default-features \
|
|
--features sqlite
|
|
#+END_SRC
|
|
|
|
** How does that look in Rust
|
|
|
|
*** Define a struct
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.50
|
|
:BEAMER_env: block
|
|
:END:
|
|
#+BEGIN_SRC rust
|
|
#[derive(Queryable)]
|
|
pub struct NewComment<'a> {
|
|
name: &'a str,
|
|
email: &'a str,
|
|
comment: &'a str,
|
|
}
|
|
#+END_SRC
|
|
|
|
*** Insert something
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
#+BEGIN_SRC rust
|
|
let user = NewUser {
|
|
name: "foo",
|
|
email: "foo@bar.baz",
|
|
comment: "A comment",
|
|
};
|
|
|
|
...
|
|
|
|
insert_into(comments)
|
|
.values(&user)
|
|
.execute(conn);
|
|
#+END_SRC
|
|
|
|
** About Diesel
|
|
- Enable connection pooling via the ~r2d2~ crate
|
|
- Nested joins are not yet nicely implemented
|
|
- Database specific SQL regarding each DBMS
|
|
- Take a look at the [[https://github.com/diesel-rs/diesel/tree/master/diesel_cli][diesel_cli]] crate for multi DBMS support
|
|
- Use ~diesel_cli~ macros and functions for compiling migration
|
|
functionality into the application
|
|
|
|
** Where to get further information?
|
|
|
|
*** Docs...
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- [[https://diesel.rs][diesel.rs]]
|
|
- [[https://diesel.rs/guides/][Diesel Guides]]
|
|
- [[https://docs.diesel.rs/master/diesel/index.html][Diesel API docs]]
|
|
- [[https://github.com/diesel-rs/diesel/tree/master/examples][Examples]] (minimalistic)
|
|
|
|
*** Support
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- [[https://gitter.im/diesel-rs/diesel][Gitter]]
|
|
- [[https://discourse.diesel.rs/][Discourse Forum]]
|
|
|
|
* Lets code something
|
|
|
|
** Lets create a small web app
|
|
A chat box where everybody can post.
|
|
#+BEGIN_CENTER
|
|
#+LaTeX:\includegraphics[width = 0.7\textwidth]{img/challenge-accepted-lets-code-it.jpg}
|
|
#+END_CENTER
|
|
|
|
*** Steps to reproduce :noexport:
|
|
|
|
**** Create new crate
|
|
#+BEGIN_SRC sh
|
|
cargo init simple_text_board
|
|
cd simple_text_board
|
|
rustup override set nightly
|
|
cargo r
|
|
#+END_SRC
|
|
|
|
**** Setup Rocket
|
|
***** Add Rocket to ~Cargo.toml~
|
|
#+BEGIN_SRC toml
|
|
[dependencies]
|
|
rocket = "0.4"
|
|
#+END_SRC
|
|
|
|
***** Add ~Rocket.toml~
|
|
#+BEGIN_SRC toml
|
|
[development]
|
|
address = "0.0.0.0"
|
|
port = 8000
|
|
workers = 2
|
|
keep_alive = 5
|
|
log = "normal"
|
|
#+END_SRC
|
|
|
|
***** Modify ~src/main.rs~ for Rockets "~Hello, world!~" program
|
|
#+BEGIN_SRC rust
|
|
// #![feature(proc_macro_hygiene, decl_macro)]
|
|
#![feature(decl_macro)]
|
|
|
|
// #[macro_use] extern crate rocket;
|
|
// #[macro_use] extern crate diesel;
|
|
|
|
#[get("/")]
|
|
fn index() -> &'static str {
|
|
"Hello, world!"
|
|
}
|
|
|
|
fn main() {
|
|
rocket::ignite().mount("/", routes![index]).launch();
|
|
}
|
|
#+END_SRC
|
|
|
|
**** Create first templates
|
|
***** Create the base template at ~templates/base.html.tera~
|
|
#+BEGIN_SRC html
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8" />
|
|
<meta name="viewport" content="width=device-width" />
|
|
<title>simple text board</title>
|
|
</head>
|
|
<body>
|
|
<ul>
|
|
<li><a href="/">home</a></li>
|
|
<li><a href="/create">create post</a></li>
|
|
</ul>
|
|
{% block content %} {% endblock %}
|
|
</body>
|
|
</html>
|
|
#+END_SRC
|
|
|
|
***** Create the create template at ~templates/create.html.tera~
|
|
#+BEGIN_SRC html
|
|
{% extends "base" %}
|
|
|
|
{% block content %}
|
|
<h1>simple text board</h1>
|
|
<h2>create a post</h2>
|
|
<form action="/create" method="post" accept-charset="utf-8">
|
|
<label for="author">author name</label>
|
|
<input type="text" placeholder="author" name="author" required>
|
|
|
|
<label for="email">email</label>
|
|
<input type="text" placeholder="email" name="email">
|
|
|
|
<label for="title">title</label>
|
|
<input type="text" placeholder="title" name="title" required>
|
|
|
|
<label for="content">content</label>
|
|
<textarea type="text" placeholder="content" name="content" rows="8" cols="50" required>
|
|
</textarea>
|
|
|
|
<button type="submit">create</button>
|
|
{% if flash %}<p>{{ flash }}</p>{% endif %}
|
|
</form>
|
|
{% endblock content %}
|
|
#+END_SRC
|
|
|
|
***** Create the ~create_form~ function and add it to routing
|
|
#+BEGIN_SRC rust
|
|
#![feature(proc_macro_hygiene, decl_macro)]
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use rocket::{get, request::FlashMessage, routes};
|
|
use rocket_contrib::templates::Template;
|
|
|
|
#[get("/create")]
|
|
fn create_form(flash: Option<FlashMessage>) -> Template {
|
|
let mut context = HashMap::new();
|
|
|
|
if let Some(ref msg) = flash {
|
|
context.insert("flash", msg.msg());
|
|
}
|
|
|
|
Template::render("create", &context)
|
|
}
|
|
|
|
...
|
|
|
|
fn main() {
|
|
rocket::ignite()
|
|
.mount("/", routes![index, create_form])
|
|
.attach(Template::fairing())
|
|
.launch();
|
|
}
|
|
#+END_SRC
|
|
|
|
**** Setup Database and posts
|
|
***** Create the ~.env~ file
|
|
#+BEGIN_SRC sh
|
|
DATABASE_URL=simple_text_board.sqlite
|
|
#+END_SRC
|
|
|
|
***** Add diesel to the dependencies and to ~rocket_contrib~ in ~Cargo.toml~
|
|
#+BEGIN_SRC toml
|
|
...
|
|
chrono = "0.4"
|
|
diesel = { version = "1.4", features = ["sqlite", "chrono"] }
|
|
log = "0.4"
|
|
...
|
|
[dependencies.rocket_contrib]
|
|
...
|
|
features = ["diesel_sqlite_pool", "tera_templates"]
|
|
#+END_SRC
|
|
|
|
***** Configure database for Rocket in ~Rocket.toml~
|
|
#+BEGIN_SRC toml
|
|
[global.databases]
|
|
sqlite = { url = "simple_text_board.sqlite" }
|
|
#+END_SRC
|
|
|
|
***** Create the first table schema
|
|
#+BEGIN_SRC sh
|
|
diesel setup
|
|
diesel migration generate create_posts
|
|
#+END_SRC
|
|
|
|
***** How to create the table
|
|
#+BEGIN_SRC sql
|
|
CREATE TABLE posts (
|
|
id INTEGER NOT NULL PRIMARY KEY,
|
|
parent INTEGER,
|
|
timestamp DATETIME NOT NULL,
|
|
author VARCHAR NOT NULL,
|
|
email VARCHAR NOT NULL,
|
|
title VARCHAR NOT NULL,
|
|
content VARCHAR NOT NULL,
|
|
FOREIGN KEY (parent) REFERENCES posts(id)
|
|
);
|
|
#+END_SRC
|
|
|
|
***** How to destroy it
|
|
#+BEGIN_SRC sql
|
|
DROP TABLE posts;
|
|
#+END_SRC
|
|
|
|
***** Applay and test rollback
|
|
#+BEGIN_SRC sh
|
|
diesel migration run
|
|
diesel migration redo
|
|
#+END_SRC
|
|
|
|
***** Create data model in ~src/models.rs~
|
|
#+BEGIN_SRC rust
|
|
use crate::schema::posts::{self, dsl::posts as table_posts};
|
|
use chrono::NaiveDateTime;
|
|
use diesel::{QueryResult, RunQueryDsl};
|
|
|
|
#[derive(Insertable)]
|
|
#[table_name = "posts"]
|
|
pub struct NewPost<'a> {
|
|
pub parent: Option<&'a i32>,
|
|
pub timestamp: NaiveDateTime,
|
|
pub author: &'a str,
|
|
pub email: &'a str,
|
|
pub title: &'a str,
|
|
pub content: &'a str,
|
|
}
|
|
|
|
impl NewPost<'_> {
|
|
pub fn insert(&self, conn: &diesel::SqliteConnection) -> QueryResult<usize> {
|
|
diesel::insert_into(table_posts).values(self).execute(conn)
|
|
}
|
|
}
|
|
#+END_SRC
|
|
|
|
***** Add create post functionality to ~src/main.rs~
|
|
#+BEGIN_SRC rust
|
|
#![feature(proc_macro_hygiene, decl_macro)]
|
|
|
|
#[macro_use]
|
|
extern crate diesel;
|
|
|
|
use std::{collections::HashMap, net::SocketAddr};
|
|
|
|
use chrono::Local;
|
|
use diesel::SqliteConnection;
|
|
use log::{error, info};
|
|
use rocket::{
|
|
get, post,
|
|
request::{FlashMessage, Form},
|
|
response::{Flash, Redirect},
|
|
routes, uri, FromForm,
|
|
};
|
|
use rocket_contrib::{database, templates::Template};
|
|
|
|
mod models;
|
|
mod schema;
|
|
|
|
use models::NewPost;
|
|
|
|
#[database("sqlite")]
|
|
struct DbCon(SqliteConnection);
|
|
|
|
#[derive(FromForm)]
|
|
pub struct PostForm {
|
|
author: String,
|
|
email: String,
|
|
title: String,
|
|
content: String,
|
|
}
|
|
|
|
...
|
|
|
|
#[post("/create", data = "<post>")]
|
|
fn create_post(
|
|
conn: DbCon,
|
|
remote_address: SocketAddr,
|
|
post: Form<PostForm>,
|
|
) -> Result<Redirect, Flash<Redirect>> {
|
|
let post = NewPost {
|
|
parent: None,
|
|
timestamp: Local::now().naive_local(),
|
|
author: &post.author.trim(),
|
|
email: &post.email.trim(),
|
|
title: &post.title.trim(),
|
|
content: &post.content.trim(),
|
|
};
|
|
|
|
match post.insert(&conn) {
|
|
Ok(_) => {
|
|
info!("New post from {}", remote_address);
|
|
Ok(Redirect::to(uri!(index)))
|
|
}
|
|
Err(e) => {
|
|
error!("Could not create post from {}: {:?}", remote_address, e);
|
|
Err(Flash::error(
|
|
Redirect::to(uri!(create_form)),
|
|
"Could not create post.".to_string(),
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
...
|
|
|
|
fn main() {
|
|
rocket::ignite()
|
|
.mount("/", routes![index, create_form, create_post])
|
|
.attach(DbCon::fairing())
|
|
.attach(Template::fairing())
|
|
.launch();
|
|
}
|
|
#+END_SRC
|
|
|
|
**** Create a template to list all posts
|
|
|
|
***** Add a template for the index page ~templates/index.html.tera~
|
|
#+BEGIN_SRC html
|
|
{% extends "base" %}
|
|
|
|
{% block content %}
|
|
<h1>simple text board</h1>
|
|
<h2>index</h2>
|
|
<ul>
|
|
{% for post in posts %}
|
|
<li>{{ loop.index }} - <a href="post/{{ post.id }}">{{ post.title }}</a> - {{ post.author }}</li>
|
|
{% endfor %}
|
|
</ul>
|
|
{% endblock content %}
|
|
#+END_SRC
|
|
|
|
***** Add serde dependencies to ~Cargo.toml~
|
|
#+BEGIN_SRC toml
|
|
chrono = { version = "0.4", features = ["serde"] }
|
|
...
|
|
serde = { version = "1.0", features = ["derive"] }
|
|
#+END_SRC
|
|
|
|
***** Add `Post` to ~src/models.rs~
|
|
#+BEGIN_SRC rust
|
|
...
|
|
use diesel::{QueryResult, RunQueryDsl, SqliteConnection};
|
|
use serde::Serialize;
|
|
|
|
...
|
|
|
|
#[derive(Debug, Queryable, Serialize)]
|
|
pub struct Post {
|
|
pub id: i32,
|
|
pub parent: Option<i32>,
|
|
pub timestamp: NaiveDateTime,
|
|
pub author: String,
|
|
pub email: String,
|
|
pub title: String,
|
|
pub content: String,
|
|
}
|
|
|
|
impl Post {
|
|
pub fn get_all(connection: &SqliteConnection) -> QueryResult<Vec<Post>> {
|
|
posts::table.load::<Post>(connection)
|
|
}
|
|
}
|
|
#+END_SRC
|
|
|
|
***** Add index template in ~src/main.rs~
|
|
#+BEGIN_SRC rust
|
|
...
|
|
use serde::Serialize;
|
|
|
|
...
|
|
|
|
use models::{NewPost, Post};
|
|
|
|
...
|
|
|
|
#[derive(Serialize)]
|
|
struct Posts {
|
|
posts: Vec<Post>,
|
|
}
|
|
|
|
#[get("/")]
|
|
fn index(conn: DbCon) -> Template {
|
|
Template::render(
|
|
"index",
|
|
Posts {
|
|
posts: Post::get_all(&conn).unwrap(),
|
|
},
|
|
)
|
|
}
|
|
#+END_SRC
|
|
|
|
**** Create page for posts
|
|
|
|
***** Create template ~templates/post.html.tera~
|
|
|
|
**** Create possibility to reply
|
|
|
|
* Conclusion
|
|
|
|
** In general
|
|
- Rust's community and ecosystem is growing steadily
|
|
- Rust covers a broad field from low level code to high level
|
|
- Rocket and libraries alike improve creating security and
|
|
performance focused web application development
|
|
- Diesel is on a good way to become a serious ORM
|
|
- Alltogether Rust is ready to be used for web apps
|
|
|
|
** What did we do?
|
|
- Setup Rust and Diesel
|
|
- Create a project with Rocket and Diesel prerequisites
|
|
- Store a small model with Diesel in a SQLite DB
|
|
- Create and use Tera templates
|
|
|
|
** Where to continue
|
|
- Move DB setup into the project
|
|
- Add features (List posts by Author, paging, etc..)
|
|
- (Private) Cookies
|
|
|
|
** Two small projects
|
|
|
|
*** [[https://git.onders.org/finga/ldap0r][ldap0r]]
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- LDAP password reset tool
|
|
- ($\sim$ 300 SloC without tests)
|
|
- First release
|
|
- Tests
|
|
|
|
*** [[https://git.onders.org/finga/webhookey][webhookey]]
|
|
:PROPERTIES:
|
|
:BEAMER_col: 0.45
|
|
:BEAMER_env: block
|
|
:END:
|
|
- Execute scripts triggered by http(s) requests
|
|
- Is becoming more and more robust
|
|
- ($\sim$ 400 SloC without tests)
|
|
|
|
** The End
|
|
#+BEGIN_CENTER
|
|
#+LaTeX:\includegraphics[width = 0.3\textwidth]{img/goodbye.jpg}
|
|
|
|
\Huge
|
|
Thanks for your attention!!1!
|
|
|
|
This is the end..
|
|
#+END_CENTER
|