bb8-postgres 0.8.1

Full-featured async (tokio-based) postgres connection pool (like r2d2)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use std::convert::Infallible;

use bb8::{Pool, RunError};
use bb8_postgres::PostgresConnectionManager;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Error, Response, Server};
use tokio_postgres::NoTls;

// Select some static data from a Postgres DB and return it via hyper.
//
// The simplest way to start the db is using Docker:
// docker run --name gotham-middleware-postgres -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 -d postgres
#[tokio::main]
async fn main() {
    let addr = ([127, 0, 0, 1], 3000).into();

    let pg_mgr = PostgresConnectionManager::new_from_stringlike(
        "postgresql://postgres:mysecretpassword@localhost:5432",
        NoTls,
    )
    .unwrap();

    let pool = match Pool::builder().build(pg_mgr).await {
        Ok(pool) => pool,
        Err(e) => panic!("bb8 error {}", e),
    };

    let _ = Server::bind(&addr)
        .serve(make_service_fn(move |_| {
            let pool = pool.clone();
            async move {
                Ok::<_, Error>(service_fn(move |_| {
                    let pool = pool.clone();
                    async move {
                        println!("Got request");
                        Ok::<_, Infallible>(match handler(pool).await {
                            Ok(rsp) => {
                                println!("Sending success response");
                                rsp
                            }
                            Err(e) => {
                                println!("Sending error response");
                                Response::new(Body::from(format!("Internal error {:?}", e)))
                            }
                        })
                    }
                }))
            }
        }))
        .await;
}

async fn handler(
    pool: Pool<PostgresConnectionManager<NoTls>>,
) -> Result<Response<Body>, RunError<tokio_postgres::Error>> {
    let conn = pool.get().await?;
    let stmt = conn.prepare("SELECT 1").await?;
    let row = conn.query_one(&stmt, &[]).await?;
    let v = row.get::<usize, i32>(0);
    Ok(Response::new(Body::from(format!("Got results {:?}", v))))
}