Rust Cookbook

The Networking section of the Rust Cookbook provides recipes for common network programming tasks using the standard library (std).

Available recipes include:

TCP/IP

• Listen on an unused TCP/IP port
• Implement a TCP echo server
• Implement a TCP client
• Connect to a TCP address with a timeout
• Set a read timeout on a TCP stream
• Disable Nagle's algorithm (nodelay)
• Half-close a TCP connection
• Perform non-blocking TCP accept

UDP

• Send and receive UDP datagrams
• Join a UDP multicast group

IP Addresses and Hostnames

• Resolve a hostname to socket addresses
• Classify an IP address
• Bind for both IPv4 and IPv6 (dual stack)

The following recipes demonstrate how to use the wasmtime host embedding API for various tasks:

• Call an exported WebAssembly function: How to load modules and invoke their exported functions.
• Exchange data via WebAssembly linear memory: How to share and manipulate linear memory between the host and the guest.
• Define host functions for WebAssembly: How to wire up host-defined functions that WebAssembly guests can call back into.
• Component Model — typed strings and structs: Using the WebAssembly Component Model to handle typed data like strings and structs (requires wasmtime and wit-bindgen).

The Rust Cookbook provides several recipes for working with databases using different crates and drivers. You can find specific implementations for SQLite, Postgres, SQLx, and SeaORM.

SQLite (using rusqlite)

• Create a SQLite database
• Insert and Query data

Postgres (using postgres)

• Create tables in a Postgres database
• Insert and Query data
• Aggregate data

SQLx (Async SQL toolkit)

• Connect to SQLite pool and simple query
• Connect to Pg Pool and query typed rows
• Compile-time checked queries
• Transactions in SQLx

SeaORM (Async ORM)

• Simple ORM pattern

The Rust Cookbook provides several recipes for interacting with HTTP clients, primarily using the reqwest crate. These recipes cover common networking tasks including:

• Basic Requests: Making HTTP GET requests.
• RESTful Operations: Setting custom headers, using URL parameters, checking if resources exist (HEAD requests), and performing POST/DELETE operations (e.g., interacting with the GitHub API).
• Pagination: Consuming paginated RESTful APIs.
• File Operations: Downloading files to temporary directories, performing partial downloads using HTTP range headers, and POSTing files to services like paste-rs.

The Rust Cookbook provides several recipes for working with asynchronous programming, primarily utilizing the tokio crate. Key topics covered include:

• Runtime Management: Using the tokio runtime macro or the Runtime Builder approach.
• File Operations: Asynchronous creation, reading, writing, and removal of files and directories, as well as working with AsyncRead and AsyncWrite traits.
• Channels: Implementing communication using both bounded and unbounded channels.
• Concurrency Control: Managing tasks using First-to-complete patterns, Task Timeouts, and Join Sets.

Use the rusqlite crate to manage SQLite databases. The Connection::open method can be used to open an existing database or create a new one if the specified file does not already exist. Once a connection is established, you can use conn.execute to run SQL commands such as CREATE TABLE to initialize your schema.

use rusqlite::{Connection, Result};

fn main() -> Result<()> {
    let conn = Connection::open("cats.db")?;

    conn.execute(
        "create table if not exists cat_colors (
             id integer primary key,
             name text not null unique
         )",
        (),
    )?;
    conn.execute(
        "create table if not exists cats (
             id integer primary key,
             name text not null,
             color_id integer not null references cat_colors(id)
         )",
        (),
    )?;

    Ok(())
}

You can control logging verbosity for specific modules using the RUST_LOG environment variable when using env_logger. Module declarations follow the format path::to::module=log_level, where entries are comma-separated. This allows you to set a global default level and override it for specific sub-modules or crates.

RUST_LOG="warn,test::foo=info,test::foo::bar=debug" ./test

To implement a simple ORM pattern using SeaORM, follow these steps:

1. Connect to a database: Use Database::connect to establish a connection (e.g., an in-memory SQLite database).
2. Initialize schema: Use Schema::create_table_from_entity to generate and create a table based on a SeaORM entity.
3. Create rows: Instantiate an ActiveModel and use ActiveModelTrait::save to persist it to the database.
4. Query rows: Use EntityTrait::find to load existing records from the database.
5. Update rows: Modify the fields of an ActiveModel and call ActiveModelTrait::save again. The method returns the updated model, allowing you to verify the saved values.