web项目怎么样改变目录结构_actix-web 的项目结构

$ tree src
src
├── dao
│   ├── mod.rs
│   └── user.rs
├── db.rs
├── main.rs
├── models
│   ├── mod.rs
│   └── user.rs
├── schema.rs
└── services
    ├── config.rs
    ├── handler
    │   ├── mod.rs
    │   └── user.rs
    └── mod.rs

use diesel::prelude::*;
use diesel::r2d2::{self, ConnectionManager};

pub type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;

pub fn create_db_pool(db_url: &str) -> Pool {
    // set up database connection pool
    let manager = ConnectionManager::<PgConnection>::new(db_url);
    let pool = r2d2::Pool::builder()
        .build(manager)
        .expect("Failed to create pool.");
    pool
}

use chrono;
use serde_derive::{Deserialize, Serialize};

use crate::schema::users;

#[derive(Queryable, PartialEq, Serialize, Deserialize, Debug)]
pub struct User {
    pub id: i64,
    pub first_name: String,
    pub last_name: String,
    pub gender: String,
    pub birthday: Option<chrono::NaiveDate>,
}

#[derive(Clone, Insertable, Serialize, Deserialize, Debug)]
#[table_name = "users"]
pub struct NewUser {
    pub first_name: String,
    pub last_name: String,
    pub gender: String,
    pub birthday: Option<chrono::NaiveDate>,
}

use actix_web::{web, HttpResponse, Error};
use crate::db::Pool;
use crate::models::user::NewUser;
use crate::dao::user as dao;

/// Finds user by id.
pub async fn get_user(
    pool: web::Data<Pool>,
    user_id: web::Path<i64>,
) -> Result<HttpResponse, Error> {
    let conn = pool.get().expect("couldn't get db connection from pool");
    let user_id = user_id.into_inner();
    // use web::block to offload blocking Diesel code without blocking server thread
    let user = web::block(move || dao::find_user_by_user_id(user_id, &conn))
        .await
        .map_err(|e| {
            eprintln!("{}", e);
            HttpResponse::InternalServerError().finish()
        })?;

    if let Some(user) = user {
        Ok(HttpResponse::Ok().json(user))
    } else {
        let res = HttpResponse::NotFound()
            .body(format!("No user found with id: {}", user_id));
        Ok(res)
    }
}

/// Execute blocking function on a thread pool, returns future that resolves
/// to result of the function execution.
pub async fn block<F, I, E>(f: F) -> Result<I, BlockingError<E>>
where
    F: FnOnce() -> Result<I, E> + Send + 'static,
    I: Send + 'static,
    E: Send + std::fmt::Debug + 'static,
{
    actix_threadpool::run(f).await
}

/// Execute blocking function on a thread pool, returns future that resolves
/// to result of the function execution.
pub fn run<F, I, E>(f: F) -> CpuFuture<I, E>
where
    F: FnOnce() -> Result<I, E> + Send + 'static,
    I: Send + 'static,
    E: Send + fmt::Debug + 'static,
{
    let (tx, rx) = oneshot::channel();
    POOL.with(|pool| {
        pool.execute(move || {
            if !tx.is_canceled() {
                let _ = tx.send(f());
            }
        })
    });

    CpuFuture { rx }
}

/// Blocking operation completion future. It resolves with results
/// of blocking function execution.
pub struct CpuFuture<I, E> {
    rx: oneshot::Receiver<Result<I, E>>,
}

impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
    type Output = Result<I, BlockingError<E>>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let rx = Pin::new(&mut self.rx);
        let res = match rx.poll(cx) {
            Poll::Pending => return Poll::Pending,
            Poll::Ready(res) => res
                .map_err(|_| BlockingError::Canceled)
                .and_then(|res| res.map_err(BlockingError::Error)),
        };
        Poll::Ready(res)
    }
}

impl<T> Future for Receiver<T> {
    type Output = Result<T, Canceled>;

    fn poll(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<T, Canceled>> {
        self.inner.recv(cx)
    }
}

/// A future for a value that will be provided by another asynchronous task.
///
/// This is created by the [`channel`] function.
#[must_use = "futures do nothing unless you `.await` or poll them"]
#[derive(Debug)]
pub struct Receiver<T> {
    inner: Arc<Inner<T>>,
}

fn recv(&self, cx: &mut Context<'_>) -> Poll<Result<T, Canceled>> {
    // Check to see if some data has arrived. If it hasn't then we need to
    // block our task.
    //
    // Note that the acquisition of the `rx_task` lock might fail below, but
    // the only situation where this can happen is during `Sender::drop`
    // when we are indeed completed already. If that's happening then we
    // know we're completed so keep going.
    let done = if self.complete.load(SeqCst) {
        true
    } else {
        let task = cx.waker().clone();
        match self.rx_task.try_lock() {
            Some(mut slot) => { *slot = Some(task); false },
            None => true,
        }
    };

    // If we're `done` via one of the paths above, then look at the data and
    // figure out what the answer is. If, however, we stored `rx_task`
    // successfully above we need to check again if we're completed in case
    // a message was sent while `rx_task` was locked and couldn't notify us
    // otherwise.
    //
    // If we're not done, and we're not complete, though, then we've
    // successfully blocked our task and we return `Pending`.
    if done || self.complete.load(SeqCst) {
        // If taking the lock fails, the sender will realise that the we're
        // `done` when it checks the `complete` flag on the way out, and
        // will treat the send as a failure.
        if let Some(mut slot) = self.data.try_lock() {
            if let Some(data) = slot.take() {
                return Poll::Ready(Ok(data));
            }
        }
        Poll::Ready(Err(Canceled))
    } else {
        Poll::Pending
    }
}

use actix_web::web::{ServiceConfig, resource as r, get, scope, post};
use crate::services::handler::user::{add_user, get_user, get_users};

pub fn config(cfg: &mut ServiceConfig) {
    cfg
        .service(
            scope("/api/v1")
                .service(r("/user/{user_id}").route(get().to(get_user)))
                .service(r("/user").route(post().to(add_user)))
                .service(r("/users").route(get().to(get_users)))
        )
        .service(scope("/api/v2")
            .service(r("/user/{user_id}").route(get().to(get_user)))
        );
}

let pool = db::create_db_pool(&db_url);

let bind = "127.0.0.1:8080";

println!("Starting server at: {}", &bind);

// Start HTTP server
HttpServer::new(move || {
    App::new()
        // set up DB pool to be used with web::Data<Pool> extractor
        .data(pool.clone())
        .wrap(middleware::Logger::default())
        .configure(config)
})
    .bind(&bind)?
    .run()
    .await

/// Finds user by id.
pub async fn get_user(
    pool: web::Data<Pool>,
    user_id: web::Path<i64>,
) -> Result<HttpResponse, Error> {
    let conn = pool.get().expect("couldn't get db connection from pool");
    // use conn
}

std::env::set_var("RUST_LOG", "actix_web=info,diesel=debug,actix=info");
env_logger::init();

// Start HTTP server
HttpServer::new(move || {
    App::new()
        // set up DB pool to be used with web::Data<Pool> extractor
        .data(pool.clone())
        .wrap(middleware::Logger::default())
        .configure(config)
})
    .bind(&bind)?
    .run()
    .await