In Chapter 4, Palmieri focuses on logging and telemetry. Axum is very different
from Actix, and my first foray into trying to understand it led me to
[Tower](https://docs.rs/tower/latest/tower/), the Rust community's de-facto
standards for modular networking development and design.
I completely short-circuited much of what the book recommended and, instead,
just went with the most basic implementation possible. I added the tracing
libraries as recommended by the Axum developers, and then implemented the first
level of tracing as recommended by Tower:
``` sh
$ cargo add --features tower_http/trace,tracing tower tower_http tracing tracing_subscriber
```
And then I updated the app startup code to include it:
``` rust
pub async fn app(configuration: &Settings) -> Router {
tracing_subscriber::fmt::init();
let pool = PgPoolOptions::new()
.max_connections(50)
.connect(&configuration.database.url())
.await
.expect("could not connect to database_url");
routes().layer(Extension(pool)).layer(TraceLayer::new_for_http())
}
```
That is literally all that was needed. And the output is:
``` plaintext
2023-03-25T16:49:06.385563Z DEBUG request{method=GET uri=/ version=HTTP/1.1}:
tower_http::trace::on_request: started processing request
2023-03-25T16:49:06.386270Z DEBUG request{method=GET uri=/ version=HTTP/1.1}:
tower_http::trace::on_response: finished processing request latency=0 ms
status=200
```
That's not great logging, but it's a start. As I understand it,
`tracing_subscriber::fmt::init()` initializes the formatter, but I'm confused as
to where this is saved or stored, since it seems to be... nowhere. The deeper
Rust gets, the wilder it seems.
What I did manage was to create, [as recommended by Chris
Allen](https://bitemyapp.com/blog/notes-on-zero2prod-rust/), a very simple Layer
that shoves a new object into the collection of data being passed around by the
request. That object contains a unique UUID for the session being processed.
Since Tokio is a multi-threaded system, having a UUID allows us to trace each
individual request from beginning to end... provided I've hooked up by handlers
just right.
I learned most of this by reading the [Axum Session source
code](https://docs.rs/axum-sessions/latest/src/axum_sessions/session.rs.html),
which implements something much more complex. Since we're at a deeper level of
the service handling I need a function takes a Request and returns a Response,
and in the middle inserts a SessionId into the Request passed in; by giving the
type a name any handlers can now find and use that SessionId:
``` rust
/// In file `session_id.rs`
pub struct SessionId(pub Uuid);
pub async fn session_id<B>(mut req: Request<B>, next: Next<B>)
-> Result<Response, StatusCode> {
req.extensions_mut().insert(SessionId(Uuid::new_v4()));
Ok(next.run(req).await)
}
```
With that, I now need to add it to the layers initialized with the app object:
```rust
/// In lib.rs:pub async fn app()`:
routes()
.layer(Extension(pool))
.layer(TraceLayer::new_for_http())
.layer(middleware::from_fn(session_id::session_id))
```
And with that, the SessionId is available. Since it's the outermost layer, it
can now be used by anything deeper in. Let's add it to the `subscribe`
function:
``` rust
/// In routes/subscribe.rs/subscribe()
pub(crate) async fn subscribe(
Extension(session): Extension<SessionId>,
Extension(pool): Extension<PgPool>,
payload: Option<Form<NewSubscription>>,
) -> Result<(StatusCode, ()), ZTPError> {
if let Some(payload) = payload {
// Multi-line strings in Rust. Ugly. Would have preferred a macro.
let sql = r#"INSERT INTO subscriptions
(id, email, name, subscribed_at)
VALUES ($1, $2, $3, $4);"#.to_string();
let subscription: Subscription = (&(payload.0)).into();
tracing::info!(
"request_id {} - Adding '{}' as a new subscriber.",
session.0.to_string(),
subscription.name
);
// ...
```
And with that, every Request now has a strong ID associated with it:
``` plaintext
2023-03-26T22:19:23.305421Z INFO ztp::routes::subscribe:
request_id d0f4a6e7-de0d-48bc-902b-713901c1d63b -
Adding 'Elf M. Sternberg' as a new subscriber.
```
That's a very noisy trace; I'd like to start knocking it down to something more
like a responsible log, or give me permission to format it the way I like. I'm
also getting incredibly noisy messages from the `sqlx::query` call, including
the text of the SQL template (the `let sql = ...` line above), which I really
don't need every time someone makes a request, and is horribly formatted for
principled analytics.
Configuring it to return JSON turned out to be easy, although my first pass
puzzled me. I had to turn `json` formatting on as a feature:
``` sh
$ cargo add --features=json tracing_subscriber
```
And then it was possible to configure the format:
``` rust
// in lib.rs:app()
// ...
let format = tracing_subscriber::fmt::format()
.with_level(false) // don't include levels in formatted output
.with_thread_names(true)
.json(); // include the name of the current thread
tracing_subscriber::fmt().event_format(format).init();
// ...
```
``` json
{
"timestamp":"2023-03-26T22:53:13.091366Z",
"fields": {
"message":"request_id 479014e2-5f13-4e12-8401-34d8f8bf1a18 - "
"Adding 'Elf M. Sternberg' as a new subscriber."},
"target":"ztp::routes::subscribe",
"threadName":"tokio-runtime-worker"
}
```
This pretty much concludes my week-long foray into Palmieri's book; I'm not
going to worry too much about the deployment stuff, since that's part of my
daytime job and I'm not interesting in going over it again.
Overall, this was an excellent book for teaching me many of the basics, and
provides a really good introduction into the way application servers can be
written in Rust. I disagree with the premise that "the language doesn't mean
anything to the outcome," as I've heard some people say, nor do I think using
Rust is some kind of badge of honor. Instead, I think it's a mark of a
responsible developer, one who can produce code that works well the first time,
and with some hard thinking about how types work (and some heavy-duty exposure
to Haskell), Rust development can be your first thought, not your "I need
speed!" thought, when developing HTTP-based application servers.
First, we're gonna expand the configuration we defined previously. The one
thing we will require is the password, although eventually I'm going to make
that a command-line option using Clap.
``` rust
pub struct DatabaseSettings {
pub username: String,
pub password: String,
pub host: String,
pub port: u16,
pub database: String,
}
pub struct Settings {
pub database: DatabaseSettings,
pub port: u16,
}
impl Default for DatabaseSettings {
fn default() -> Self {
DatabaseSettings {
username: "newsletter".to_string(),
password: "".to_string(),
host: "localhost".to_string(),
port: 5432,
database: "newsletter".to_string(),
}
}
}
impl Default for Settings {
fn default() -> Self {
Settings {
port: 3001,
database: DatabaseSettings::default(),
}
}
}
```
The code's beginning to get a bit messsy. So let's re-arrange. I already have
the configuration handler in its own file, but let's clean up the routes. I'm
going to take the functions I've already defined and put them in a subfolder,
`src/routes`, and then for each one I'll make a new file. For example:
``` rust
use axum::{http::StatusCode, response::IntoResponse};
pub(crate) async fn health_check() -> impl IntoResponse {
(StatusCode::OK, ())
}
```
Just a note: *ignore* your IDE's "advice" to remove the unneeded `async`; Axum
will not compile this module correctly, `IntoResponse` requires that it be an
async function. I don't know why rust-analyzer failed to pick that up.
Now make a `src/routes.rs` (yes, the same name as the folder). You can activate
and de-activate routes at will:
``` rust
use axum::{
routing::{get, post},
Router,
};
mod greet;
use greet::greet;
mod health_check;
use health_check::health_check;
mod index;
use index::index;
mod subscribe;
use subscribe::subscribe;
pub(crate) fn app() -> Router {
Router::new()
.route("/", get(index))
.route("/subscriptions", post(subscribe))
.route("/:name", get(greet))
.route("/health_check", get(health_check))
}
```
You don't need the `use` clauses, you could just say `index::index`, but I kinda
like the way this looks, even with the repetition. It makes it clear what I'm
doing and what I'm looking at. This is Rust 2021, where the presence of a file
and a folder with the same name indicate a module with submodules. In prior
editions of rust, instead of `routes.rs`, we would have used `routes/mod.rs`.
I'm not entirely sure which I like better.
Now that that's done, in our `lib.rs`, we use the `routes`:
``` rust
use std::net::SocketAddr;
mod configuration;
use configuration::get_configuration;
mod routes;
use routes::app;
pub async fn run() {
let configuration = get_configuration().unwrap();
let addr = SocketAddr::from(([127, 0, 0, 1], configuration.port));
tracing::info!("listening on {}", addr);
axum::Server::bind(&addr)
.serve(app().into_make_service())
.await
.unwrap()
}
```
All of the Axum imports have been removed, since they're part of the routes.
Nice, clean and clear code. At this point, even `cargo clippy` is happy.
Connecting to a database these days involves a URL. Let's make it easy to
generate one. Now, we could implement the trait `std::string::ToString`, or
`Display`, but that would conflict with any debugging information. Instead,
let's define a new method in `configuration.rs`:
``` rust
impl DatabaseSettings {
pub fn url(&self) -> String {
if self.password.len() == 0 {
format!(
"postgres://{}@{}:{}/{}",
self.username, self.host, self.port, self.database
)
} else {
format!(
"postgres://{}:{}@{}:{}/{}",
self.username, self.password, self.host, self.port, self.database
)
}
}
}
```
It is possible (unwise, but possible) to connect to a Postgres database with no
password. In a dynamic language this would have been less wordy, but I can't
complain about Rust being a little extra verbose in exchange for being a lot
more precise.
Since we're using Postgres, in `lib.rs` we'll add `use
sqlx::postgres::PgPoolOptions;`, which will allow us to create a pool of workers
and limit how many there are. In the `run()` function, we're going to extract
the `app()` definition and use it:
``` rust
use axum::Extension;
use sqlx::postgres::PgPoolOptions;
// in: fn run()
let pool = PgPoolOptions::new()
.max_connections(50)
.connect(&configuration.database.url())
.await
.expect("could not connect to database_url");
let routes = app().layer(Extension(pool));
tracing::info!("listening on {}", addr);
axum::Server::bind(&addr)
.serve(routes.into_make_service())
.await
.unwrap()
```
Now we have a configuration that is runnable. If you run it as-is, it will fail
because, if you set up your Postgres database correctly, there is no password.
Create a `ztp.config.yaml` file (or JSON, or TOML, or whatever floats your boat)
and establish the password:
``` yaml
database:
password: redacted
```
At one point, I had this file named only `ztp.config`, and unfortunately it
crashed. Adding `#[derive(Debug)]` to my configuration structs helped show that
the password wasn't getting set, but it took me a few minutes to realize that
I'd forgotten the extension so `Config` didn't know how to read the file. Naming
it `ztp.config.yaml` fixed it, and this illustrates just how useful TOML can be
in circumstances like this.
This turned out to be a bit of a beast, and I'm incredibly indebted to Carlos
Armando Marcano Vargas and [his blog](https://github.com/carlosm27/blog) where
he documented much of what I needed to make this work with Axum.
In the migrations file, we specified that the primary key of our subscriptions
table would be a UUID, and that we were going to record when the subscription
happened. To do this, first we have to make sure that we have the `Uuid` and
`Chrono` crates, and that they're all hooked up for proper serialization:
``` toml
chrono = { version = "0.4.24", features = ["serde"] }
uuid = { version = "1.3.0", features = ["v4", "serde"] }
sqlx = { version = "0.6.3", features = ["runtime-tokio-native-tls", "macros",
"postgres", "uuid", "chrono"] }
```
Both of the new creates need `serde` as a feature and we'll be using `UUID4` for
our primary key.
We'll also need a full subscription object to store, and then a
way to generate it from a new subscription:
```rust
pub(crate) struct NewSubscription {
pub email: String,
pub name: String,
}
struct Subscription {
pub id: Uuid,
pub email: String,
pub name: String,
pub subscribed_at: DateTime<Utc>,
}
impl From<&NewSubscription> for Subscription {
fn from(s: &NewSubscription) -> Self {
Subscription {
id: Uuid::new_v4(),
email: s.email.clone(),
name: s.name.clone(),
subscribed_at: Utc::now(),
}
}
}
```
I've renamed "Subscription" to "NewSubscription" to distinguish it from the
thing we're going to reliably keep in our database, which has all the fields.
And now we're going to re-write the `subscribe()` function to actually talk to
the database. All of those parens around the `payload` are necessary to help
Rust understand what we want to borrow. You'll note that it's `payload.0`, not
just `payload`; Form objects can have multiple instances of their content.
``` rust
pub(crate) async fn subscribe(Extension(pool): Extension<PgPool>,
payload: Form<NewSubscription>) ->
impl IntoResponse {
let sql = r#"INSERT INTO subscriptions (id, email, name,
subscribed_at) VALUES ($1, $2, $3, $4);"#.to_string();
let subscription: Subscription = (&(payload.0)).into();
let _ = sqlx::query(&sql)
.bind(subscription.id)
.bind(subscription.email)
.bind(subscription.name)
.bind(subscription.subscribed_at)
.execute(&pool)
.await
.expect("Failed for some reason?");
(StatusCode::OK, ())
}
```
Alternatively, I could have written:
``` rust
let subscription = Subscription::from(&(payload.0));
```
Either way works.
That unused `.expect()` has Tokio panicking if I give it a duplicate email
address, as one of the constraints in our original migration reads:
``` sql
email text not null unique,
```
We want to catch and handle that error. We also want to fix something that's
been sitting in the "TODO" list for awhile: make sure that when the subscription
form isn't fully filled out, we return a straight 400. That's actually the
easier part: we make the payload optional and return our default `BAD_REQUEST`
if it's not there:
``` rust
pub(crate) async fn subscribe(
Extension(pool): Extension<PgPool>,
payload: Option<Form<NewSubscription>>,
) -> impl IntoResponse {
if let Some(payload) = payload {
...
(StatusCode::OK, ())
} else {
(StatusCode::BAD_REQUEST, ())
}
```
So, handling the errors is going to be interesting. Going above and beyond,
it's time to use `thiserror`.
Rust has an excellent error handling story, with the `Result<T, impl Error>`,
although mostly this is just a way of distinguishing and annotating errors in a
robust, type-safe manner; it's still up to the programmer to handle errors. A
library has a set of error states that it can return, and `thiserror` is a set
of macros that automatically annotate your list of errors with messages and
values.
Right now we have two possible errors: the form data passed in was incomplete,
or the email address submitted already exists. (We're not even checking the
email address for validity, just existence.) So let's create those errors and
provide them with labels. We'll just put this in a file named `errors.rs`, in
the root of the crate; that seems to be where everyone puts it, and it's a nice
convention.
``` rust
pub enum ZTPError {
#[error("Form data was incomplete")]
FormIncomplete,
#[error("Email address already subscribed")]
DuplicateEmail,
}
```
And now the error will always be "400: Bad Response", but the text of the
message will be much more descriptive of what went wrong.
We have to edit the `subscribe` function to handle these changes: first, the
return type must change, and then the errors must be included:
``` rust
pub(crate) async fn subscribe(
Extension(pool): Extension<PgPool>,
payload: Option<Form<NewSubscription>>,
) -> Result<(StatusCode, ()), ZTPError> {
// ...
.map_or(Ok((StatusCode::OK, ())), |_| Err(ZTPError::DuplicateEmail))
} else {
Err(ZTPError::FormIncomplete)
}
```
We've changed the function to take an `Option<Form<>>`; this way, if we don't
get a form that deserialized properly we'll be able to say "That wasn't a good
form," and we've changed the result so that we can return our error. Then we
changed our two edge cases to report the errors.
Axum doesn't know what a ZTPError is, but we can easily make our errors to
something Axum does understand. We'll just have to implement our own
`IntoResponse`, and we'll put it in `errors.rs`:
``` rust
impl IntoResponse for ZTPError {
fn into_response(self) -> axum::response::Response {
let (status, error_message) = match self {
Self::FormIncomplete => (StatusCode::BAD_REQUEST, self.to_string()),
Self::DuplicateEmail => (StatusCode::BAD_REQUEST, self.to_string()),
};
(status, Json(json!({ "error": error_message }))).into_response()
}
}
```
... and with that, we can now change all of the tests to watch for `400` codes,
as that ancient TODO said, and it will all just work.
*Holy Chao*, we've made it through the "writing the application" stuff, and a
lot of what was in the book is... no longer quite so relevant. There's whole
sections on getting Actix to type-match with your code that Axum and 2021 Rust
make more or less irrelevant, and by using features like `thiserror` and
`dbmate` we've managed to route around many of the bulkier difficulties in the
book.
The next chapter is about logging and monitoring. ɡɡ
This chapter introduces the Actix "Extractors" for retrieving form data. I've
added tests to the `./tests` folder to attempt to interact with those
extractors; as of this commit, a89cbe5b, they fail because the example code
isn't there.
What is there is a variant of the "Hello, World!" code from the previous
exercises (section 3.5), which uses the Actix extractor:
``` rust
// Actix, *not* Axum. Does not work with the current framework.
fn index(form: web::Form<FormData>) -> String {
format!('Welcome {}!', form.username)
}
```
Translated and polished into Axum, it translates to:
``` rust
pub async fn index(payload: Option<Form<FormData>>) -> impl IntoResponse {
let username = payload.map_or("World".to_string(), move |index| -> String {
String::from(&(index.username))
});
(StatusCode::OK, format!("Hello, {}!\n", &username))
}
```
The Axum version is a little smarter, providing a default "World!" if you don't
specify a name. That's what `.map_or` does, although the `or` part actually
comes first in the function. So the result is:
``` sh
$ curl http://localhost:3000/
Hello, World!
$ curl 'http://localhost:3000/?username=Spock'
Hello, Spock!
```
Which is more or less the version we want.
**Section 3.7.3** then goes into some detail on the implementation of a Trait.
A Trait in Rust is like an Interface in other languages; it describes a
collection of functions for manipulating the values found in a defined Type.
**Types**: A Type is just a description of the value: `u16` is a sixteen-bit
unsigned integer; `char` is a Unicode character, and it's size is always 32bits,
but a `String` is a bunch of things: it's an array of characters (which are not
always `char`!), a length for that string and a capacity. If the String is
manipulated to exceed the capacity, the array is re-allocated to a new capacity
and the old array copied into it. A `Vec<String>` is an array of Strings; as a
Type, it is considered to have a single value: whatever is in it at the moment
you use it.
**Trait**: A Trait defines a collection of one or more functions that can
operate on a value.
The truly nifty thing about Traits is that they can be implemented after the
fact. By importing a Trait and an implementation of that trait specific to a
type into a module containing that type, you can extend the behavior of a type
in a deterministic way without having to modify or inherit the code, as you
would in an object-oriented language.
Axum has a valuable trait, `FromRequest`. For any structure you can imagine
passing from the client to the server, you can implement `FromRequest` for that
object and any content in the body of the message will be transformed into that
structure.
We've seen a trait before: `IntoResponse`, written as `impl IntoResponse`, and
is the output (the return type) of many of the functions that produce return
values for our application server. In this case the return type instructs Rust
to look in the current lexical scope and, for the value returned by that
function, determine if an `IntoResponse` trait has been defined for it. If it
has, the value will be returned because Axum has now been assured that there
exists a function to convert that value into something streamable and usable as
an HTTP response.
Fortunately for us, Axum has already implemented `FromRequest` for all the
native data types, as well as some structures and arrays. Even better, it has
implemented `FromRequest` for the Serde serialization/deserialization library.
So in this example:
``` rust
pub struct FormData {
username: String,
}
pub async fn index(payload: Option<Form<FormData>>) -> impl IntoResponse { ...
```
A `Form` (something using the `application/x-www-form-urlencoded` protocol) of
`FormData` will automatically be converted into a `payload` object of `{
username: "Spock" )`, and in this case wrapped in a `Some()` handler. (Or
`None`, if there was no form included.) <aside>So far, there's not too much
bloat in this product; with all the debugging symbols, it's 60MB or so, but
stripped to the bone it's only 3.1MB, tolerable for modern deployments.</aside>
First, though, we must adjust our `valid_subscription` test:
``` rust
let body = "name=le%20guin&email=ursula_le_guin%40gmail.com";
let response = hyper::Client::new()
.request(
Request::builder()
.method("POST")
.header("content-type", "application/x-www-form-urlencoded")
.uri(format!("http://{}/subscriptions", addr))
.body(Body::from(body))
.unwrap(),
)
.await
.expect("Failed to execute request.");
```
Two updates from the book: first, we're sending it via POST instead of GET. This
is the correct way to do things; a GET should never (and I mean *never*) cause a
change of state on the back-end. To send something new that the server will
process and store, you use a POST. (To update something, or to send something to
a known *and unique* URI, PUT is better.) Secondly, since we're using a generic
form-data object, we need to set the content-type on the client so that the
server is informed of how to unpack this payload. The '%20' and '%40' markers in
the `body` are the space and the `@` respectively.
I completely ignored the advice in the book and went instead with
[Dbmate](https://github.com/amacneil/dbmate); Dbmate is a bit cranky; your SQL
must be very much nestled against the 'up' and 'down' markers in the migration
file, and it seems to be quite opinionated about everything being lowercase.
That said, it was trivial to create a database with it:
``` sh
$ dbmate new create_subscriptions_table
```
This will create the folder
`db/migrations/20230322174957_create_subscriptions_table.sql`,
(The timestamp will be different, obviously), and in this file you put the
following, as specified in the book:
``` sql
-- migrate:up
create table subscriptions (
id uuid not null,
primary key (id),
email text not null unique,
name text not null,
subscribed_at timestamptz not null
);
-- migrate:down
drop table subscriptions;
```
To use Dbmate, you have to specify how to connect. I'm using Postgres, so let's
start with creating a database and a user for it:
``` sh
$ sudo -u postgres psql
[sudo] possword for user: ...................
postgres=# create database newsletter;
CREATE DATABASE
postgres=# create user newletter with encrypted password 'redacted';
CREATE USER
postgres=# grant all privileges on database newsletter to newsletter;
GRANT
postgres=# exit
```
In your project root, create a `.env` file to specify your connection:
``` sh
DATABASE_URL="postgres://newsletter:redacted@127.0.0.1:5432/newsletter?sslmode=disable"
```
The `sslmode` flag there is necessary for localhost connections, as Dbmate
assumes an encrypted connection by default, but we're isolating to a local
connection that is, usually, safe.
With the new entry in your `.env` file, you can now run a migration:
``` sh
$ dbmate up
Writing: ./db/schema.sql
```
Running `dbmate up` will automatically create the database for you if it hasn't
already; `dbmate migrate` also performs migrations, but it will not create the
database.
Now you can re-connect to Postgres as the newsletter user and see what you've
got:
``` sh
$ psql --user newsletter -h localhost --password
Password:
psql (14.7 (Ubuntu 14.7-0ubuntu0.22.04.1), server 11.7 (Ubuntu 11.7-0ubuntu0.19.10.1))
newsletter=> \d
List of relations
Schema | Name | Type | Owner
--------+-------------------+-------+------------
public | schema_migrations | table | newsletter
public | subscriptions | table | newsletter
(2 rows)
newsletter=> \d subscriptions
Table "public.subscriptions"
Column | Type | Collation | Nullable | Default
---------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
email | text | | not null |
name | text | | not null |
subscribed_at | timestamp with time zone | | not null |
Indexes:
"subscriptions_pkey" PRIMARY KEY, btree (id)
"subscriptions_email_key" UNIQUE CONSTRAINT, btree (email)
```
Note that Dbmate has allocated a table to itself, `schema_migrations`, for
tracking what it's done to your system and when. Try not to conflict with it,
okay?
Every complex app has a configuration, and there are plenty of different ways
the configuration can be specified. Environment variables, internal defaults,
and configuration files-- the last of which comes in so many different flavors.
Rust has a well-known [config](https://docs.rs/config/latest/config/index.html)
crate that supports all the most common configurations: YAML, JSON, TOML; you
can even add your own by writing something that implements the `config::Format`
trait. Add it to Cargo.toml:
``` sh
$ cargo add config
```
For the meantime, we're just going to create a new file, called
`configuration.rs`, and put our configuration details in there. Right now we
have a single configuration detail: the port.
I'm going to go above and beyond Lucas here and configure some internal defaults
for my code. It will have expectations. First, you have to tell Serde that
there will be default values:
``` rust
use config::Config;
pub struct Settings {
pub port: u16,
}
```
Then, you have to set those default values. Fortunately, Rust provides a "set
default values" trait named, sensibly enough, Default:
``` rust
impl Default for Settings {
fn default() -> Self {
Settings { port: 3001 }
}
}
```
Again, exceeding the book's parameters, I'm going to say that if the file is
missing the default parameters should hold:
``` rust
pub(crate) fn get_configuration() -> Result<Settings, config::ConfigError> {
Config::builder()
.add_source(config::File::with_name("./ztd.config").required(false))
.build()?
.try_deserialize()
}
```
And since this is the first time I'm doing this, I'm going to write a test to
assert that my understanding of how this all works is correct:
``` rust
mod tests {
use super::*;
#[test]
fn test_for_defaults() {
let maybe_config = get_configuration();
assert!(!maybe_config.is_err());
let config = maybe_config.unwrap();
assert_eq!(config.port, 3001);
}
}
```
Re-reading the text, I made a number of changes. The first is that, while it is
nice that Rust allows us to have unit tests in the file whose functionality
we're testing, it's also nice to have the tests somewhere separate, and to have
the tests be a little more modular.
In the `./tests` folder, you can now see the same `health_check` test as the
original, but in an isolated and cleaned-up form. Most importantly, the server
startup code is now in its own function, with a correct return type that
includes a handle to the spawned thread and the address on which that server is
listening; tests can be run in parallel on many different ports and a lot of
code duplication is eliminated.
``` rust
type NullHandle = JoinHandle<()>;
async fn spawn_server() -> (SocketAddr, NullHandle) {
let listener = TcpListener::bind("127.0.0.1:0".parse::<SocketAddr>().unwrap()).unwrap();
let addr = listener.local_addr().unwrap();
let handle: NullHandle = tokio::spawn(async move {
axum::Server::from_tcp(listener)
.unwrap()
.serve(app().into_make_service())
.await
.unwrap();
});
(addr, handle)
}
```
It is also possible now to add new tests in a straightforward manner. The
Hyper API is not that much different from the Actix request API, and the Axum
extractors seem to be straightforward. I suspect that what I'm looking at here
with the handle is the idea that, when it goes out of scope, it calls a d
In the introduction I said I was going to be neglecting CI/CD, since I'm a solo
developer. That's true, but I do like my guardrails. I like not being able to
commit garbage to the repository. So I'm going to add some checks, using
[Pre-Commit](https://pre-commit.com/).
Pre-Commit is a Python program, so we'll start by installing it. I'm using a
local Python environment kickstarted with
[Pyenv](https://github.com/pyenv/pyenv).
``` sh
$ pip install pre-commit
```
And inside your project, in the project root, you hook it up with the following commands:
``` sh
$ pre-commit install
$ pre-commit sample-config > .pre-commit-config.yaml
```
I'm going with the default from the rust pre-commit collection, so my
`.pre-commit-config.yaml` file looks like this:
``` yaml
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v3.1.0
hooks:
- id: check-byte-order-marker
- id: check-case-conflict
- id: check-merge-conflict
- id: check-symlinks
- id: check-yaml
- id: end-of-file-fixer
- id: mixed-line-ending
- id: trailing-whitespace
- repo: https://github.com/pre-commit/pre-commit
rev: v2.5.1
hooks:
- id: validate_manifest
- repo: https://github.com/doublify/pre-commit-rust
rev: master
hooks:
- id: fmt
- id: cargo-check
- id: clippy
```
... and with that, every time I try to commit my code, it will not let me until
these tests pass. And I *like* that level of discipline. This is low-level
validation; it won't catch if I put addition where I meant subtraction, or if I
have a comparison going in the wrong direction, but at least the basics are
handled and, more importantly, the formatting and styling is consistent
throughout all of my code.
Shichao is one of those compulsive documentarians, but unlike myself
he has a much more disciplined style. I intend to try and match it
during these tutorials.
Since this book is about learning Rust, primarily in a microservices
environment, this chapter focuses on installing Rust and describing the tools
available to the developer.
The easiest way to install Rust is to install the [Rustup](https://rustup.rs/)
tool. It is one of those blind-trust-in-the-safety-of-the-toolchain things. For
Linux and Mac users, the command is a shell script that installs to a user's
local account:
```
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Once installed, you can install Rust itself:
```
$ rustup install toolchain stable
```
You should now have Rust compiler and the Rust build and packaging tool, known
as Cargo:
```
$ rustc --version
rustc 1.68.0 (2c8cc3432 2023-03-06)
$ cargo --version
cargo 1.68.0 (115f34552 2023-02-26)
```
I also installed the following tools:
```
$ rustup component add clippy rust-src rust-docs
$ cargo install rustfmt rust-analyzer
```
- clippy: A powerful linter that provides useful advice above and beyond the
compiler's basic error checking.
- rustfmt: A formatting tool that provides a common format for most developers
- rust-analyzer: For your IDE, rust-analyzer provides the LSP (Language Server
Protocol) for Rust, giving you code completion, on-the-fly error definition,
and other luxuries.
Zero-to-Production's project is writing a web service that signs people up for
an email newsletter. The first task in the book is to set up a "Hello World!"
application server.
The book uses the [Actix-web](https://actix.rs/) web framework, but I've chosen
to implement it using [Axum](https://github.com/tokio-rs/axum) server, the
default server provided by the [Tokio](https://github.com/tokio-rs/tokio)
asynchronous runtime.
Although the book is only two years old, it is already out-of-date with respect
to some commands. `cargo add` is now provided by default. The following
commands installed the tools I'll be using:
```
cargo add --features tokio/full --features hyper/full tokio hyper \
axum tower tracing tracing-subscriber
```
- axum: The web server framework for Tokio.
- tokio: The Rust asynchronous runtime. Has single-threaded (select) and
multi-threaded variants.
- [hyper](https://hyper.rs/): An HTTPS request/response library, used for testing.
- [tracing](https://crates.io/crates/tracing): A debugging library that works
with Tokio.
We start by defining the core services. In the book, they're a greeter ("Hello,
World"), a greeter with a parameter ("Hello, {name}"), and a health check
(returns a HTTP 200 Code, but no body). Actix-web hands a generic Request and
expects a generic request, but Axum is more straightforward, providing
`IntoResponse` handlers for most of the basic Rust types, as well as some for
formats via Serde, Rust's standard serializing/deserializing library for
converting data from one format to another.
All of these go into `src/lib.rs`:
```
async fn health_check() -> impl IntoResponse {
(StatusCode::OK, ())
}
async fn anon_greet() -> &'static str {
"Hello World!\n"
}
async fn greet(Path(name): Path<String>) -> impl IntoResponse {
let greeting = String::from("He's dead, ") + name.as_str();
let greeting = greeting + &String::from("!\n");
(StatusCode::OK, greeting)
}
```
<aside>Axum's documentation says to [avoid using `impl
IntoResponse`](https://docs.rs/axum/latest/axum/response/index.html#regarding-impl-intoresponse)
until you understand how it really works, as it can result in confusing issues
when chaining response handlers, when a handler can return multiple types, or
when a handler can return either a type or a [`Result<T,
E>`](https://doc.rust-lang.org/std/result/), especially one with an error.</aside>
We then define the routes that our server will recognize. This is
straightforward and familiar territory:
```
fn app() -> Router {
Router::new()
.route("/", get(anon_greet))
.route("/:name", get(greet))
.route("/health_check", get(health_check))
}
```
We then define a function to *run* the core server:
```
pub async fn run() {
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
tracing::info!("listening on {}", addr);
axum::Server::bind(&addr)
.serve(app().into_make_service())
.await
.unwrap()
}
```
And finally, in a file named `src/main.rs`, we instantiate the server:
```
use ztp::run;
async fn main() {
run().await
}
```
To make this "work," we need to define what `ztp` means, and make a distinction
between the library and the CLI program.
In the project root's `Cargo.toml` file, the first three sections are needed to
define these relationships:
```
[package]
name = "ztp"
version = "0.1.0"
edition = "2021"
[lib]
path = "src/lib.rs"
[[bin]]
path = "src/main.rs"
name = "ztp"
```
It is the `[package.name]` feature that defines how the `use` statement in
`main.rs` will find the library. The `[[bin]]` clause defines the name of the
binary when it is generated. <aside>The double brackets around the `[[bin]]`
clauses is there to emphasize to the TOML parser that there can be more than one
binary. There can be only one library per package, but it is possible for a Rust
project to have more than one package, called "crates," per project. </aside>
This project should now be runnable. In one window, type:
```
$ cargo run
```
And in another, type and see the replies:
```
$ curl http://localhost:3000/
Hello, World!
$ curl http://localhost:3000/Jim
He's dead, Jim!
$ curl -v http://localhost:3000/health_check
> GET /health_check HTTP/1.1
> Host: localhost:3000
> User-Agent: curl/7.81.0
> Accept: */*
< HTTP/1.1 200 OK
< content-length: 0
< date: Tue, 21 Mar 2023 00:16:43 GMT
```
In the last command, the *verbose* flag shows us what we sent to the server, and
what came back. We expected a "200 OK" flag and a zero-length body, and that's
what we got.
In order to unit-test a web server, we must spawn a copy of it in order to
exercise its functions. We'll use Tokio's `spawn` function to create a new
server, use hyper to request data from the server, and finally Rust's own native
test asserts to check that we got what we expected.
```
mod tests {
use super::*;
use axum::{
body::Body,
http::{Request, StatusCode},
};
use std::net::{SocketAddr, TcpListener};
#[tokio::test]
async fn the_real_deal() {
let listener = TcpListener::bind("127.0.0.1:0".parse::<SocketAddr>()
.unwrap()).unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
axum::Server::from_tcp(listener)
.unwrap()serve(app().into_make_service()).await.unwrap();
});
let response = hyper::Client::new()
.request(
Request::builder().uri(format!("http://{}/", addr))
.body(Body::empty()).unwrap(),
)
.await
.unwrap();
let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
assert_eq!(&body[..], b"Hello World!\n");
}
}
```
One interesting trick to observe in this testing is the port number specified in
the `TcpListener` call. It's zero. When the port is zero, the `TcpListener` will
request from the kernel the first-free-port. Normally, you'd want to know
exactly what port to call the server on, but in this case both ends of the
communication are aware of the port to use and we want to ensure that port isn't
hard-coded and inconveniently already in-use by someone else.
Elf M. Sternberg