Verified Commit 2a81c993 authored by Mattia Righetti's avatar Mattia Righetti
Browse files

refactor: misc handlers logic changes 

+ concurrently query totals, published and relays/bridges data with `tokio::try_join`
+ limit behaviour changed

if you ask for `limit=10` and specify no type, the response is going to contain
10 bridges and 10 relays
parent 98473e0e

src/handlers/bandwidth.rs

+25 −33
Original line number Diff line number Diff line
@@ -20,55 +20,47 @@ pub async fn get_bandwidth( 
    let mut response = lock.get();

    drop(lock);



    let relay_published = metrics::relays_published(&pg).await.map_err(ErrorInternalServerError)?;

    let bridges_published =

        metrics::bridges_published(&pg).await.map_err(ErrorInternalServerError)?;

    let res = tokio::try_join!(

        metrics::published(&pg),

        metrics::totals(&pg),

        metrics::relay_bandwidth(&pg, &params),

        metrics::bridge_bandwidth(&pg, &params)

    )

    .map_err(ErrorInternalServerError)?;



    response.relays_published(relay_published);

    response.bridges_published(bridges_published);

    let ((bridges_pub, relays_pub), (tot_relays, tot_bridges), relays, bridges) = res;



    response.relays_published(relays_pub);

    response.bridges_published(bridges_pub);

    response.relays_skipped(params.offset.map(|f| f.into()));

    response.relays_truncated(get_truncated(10000000, params.limit, params.offset));

    response.relays_truncated(get_truncated(

        tot_relays as i32,

        params.limit,

        params.offset,

    ));

    response.bridges_skipped(params.offset.map(|f| f.into()));

    response.bridges_truncated(get_truncated(100000000, params.limit, params.offset));

    response.bridges_truncated(get_truncated(

        tot_bridges as i32,

        params.limit,

        params.offset,

    ));



    match params.r#type {

        Some(t) => match t {

            ParametersType::Relay => {

                let relays = metrics::relay_bandwidth(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(RelayBandwidth::from)

                    .collect();



                let relays = relays.into_iter().map(RelayBandwidth::from).collect();

                response.relays(relays);

                response.bridges(vec![]);

            }

            ParametersType::Bridge => {

                let bridges = metrics::bridge_bandwidth(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(BridgeBandwidth::from)

                    .collect();



                let bridges = bridges.into_iter().map(BridgeBandwidth::from).collect();

                response.relays(vec![]);

                response.bridges(bridges);

            }

        },

        None => {

            let relays = metrics::relay_bandwidth(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(RelayBandwidth::from)

                .collect();

            let bridges = metrics::bridge_bandwidth(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(BridgeBandwidth::from)

                .collect();

            let relays = relays.into_iter().map(RelayBandwidth::from).collect();

            let bridges = bridges.into_iter().map(BridgeBandwidth::from).collect();



            response.relays(relays);

            response.bridges(bridges);

src/handlers/details.rs

+36 −18
Original line number Diff line number Diff line
@@ -20,30 +20,48 @@ pub async fn get_details( 
    let mut response = lock.get();

    drop(lock);



    let relay_published = metrics::relays_published(&pg).await.map_err(ErrorInternalServerError)?;

    let bridges_published =

        metrics::bridges_published(&pg).await.map_err(ErrorInternalServerError)?;

    let res = tokio::try_join!(

        metrics::published(&pg),

        metrics::totals(&pg),

        metrics::relay_details(&pg, &params),

        metrics::bridge_details(&pg, &params)

    )

    .map_err(ErrorInternalServerError)?;



    response.relays_published(relay_published);

    response.bridges_published(bridges_published);

    let ((bridges_pub, relays_pub), (tot_relays, tot_bridges), relays, bridges) = res;



    response.relays_published(relays_pub);

    response.bridges_published(bridges_pub);

    response.relays_skipped(params.offset.map(|f| f.into()));

    response.relays_truncated(get_truncated(1000000, params.limit, params.offset));

    response.relays_truncated(get_truncated(

        tot_relays as i32,

        params.limit,

        params.offset,

    ));

    response.bridges_skipped(params.offset.map(|f| f.into()));

    response.bridges_truncated(get_truncated(1000000, params.limit, params.offset));

    response.bridges_truncated(get_truncated(

        tot_bridges as i32,

        params.limit,

        params.offset,

    ));



    match params.r#type.unwrap_or(ParametersType::Relay) {

    match params.r#type {

        Some(t) => match t {

            ParametersType::Relay => {

            let relays =

                metrics::relay_details(&pg, &params).await.map_err(ErrorInternalServerError)?;



                let relays = relays.into_iter().map(RelayDetails::from).collect();

                response.relays(relays);

                response.bridges(vec![]);

            }

            ParametersType::Bridge => {

            let bridges =

                metrics::bridge_details(&pg, &params).await.map_err(ErrorInternalServerError)?;



                let bridges = bridges.into_iter().map(BridgeDetails::from).collect();

                response.relays(vec![]);

                response.bridges(bridges);

            }

        },

        None => {

            let relays = relays.into_iter().map(RelayDetails::from).collect();

            let bridges = bridges.into_iter().map(BridgeDetails::from).collect();

            response.relays(relays);

            response.bridges(bridges);

        }

    }

src/handlers/exit_node.rs

+24 −53
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ use sqlx::PgPool; 


use crate::metrics;

use crate::models::factory::ResponseFactory;

use crate::models::query::{domain::ParametersType, params::QueryFilters};

use crate::models::query::params::QueryFilters;

use crate::models::responses::exit_node::ExitNode;

use crate::utils::get_truncated;
@@ -15,62 +15,33 @@ pub async fn get_exit_node( 
    pg: web::Data<PgPool>,

) -> Result<HttpResponse, Error> {

    let lock = factory.read().unwrap();

    let mut response = lock.get();

    let mut response = lock.get::<ExitNode, ExitNode>();

    drop(lock);



    let relay_published = metrics::relays_published(&pg).await.map_err(ErrorInternalServerError)?;

    let bridges_published =

        metrics::bridges_published(&pg).await.map_err(ErrorInternalServerError)?;

    let res = tokio::try_join!(

        metrics::published(&pg),

        metrics::totals(&pg),

        metrics::exit_addresses(&pg, &params),

    )

    .map_err(ErrorInternalServerError)?;



    response.relays_published(relay_published);

    response.bridges_published(bridges_published);

    response.relays_skipped(params.offset.map(|f| f.into()));

    response.relays_truncated(get_truncated(100000, params.limit, params.offset));

    response.bridges_skipped(params.offset.map(|f| f.into()));

    response.bridges_truncated(get_truncated(100000, params.limit, params.offset));



    match params.r#type {

        Some(t) => match t {

            ParametersType::Relay => {

                let relays = metrics::exit_addresses(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(ExitNode::from)

                    .collect();

    let ((bridges_pub, relays_pub), (tot_relays, tot_bridges), exit_addresses) = res;



                response.relays(relays);

    response.relays_published(relays_pub);

    response.bridges_published(bridges_pub);

    response.relays_skipped(params.offset.map(|f| f.into()));

    response.relays_truncated(get_truncated(

        tot_relays as i32,

        params.limit,

        params.offset,

    ));



    response.bridges_skipped(Some(0));

    response.bridges_truncated(tot_bridges as i32);

    response.bridges(vec![]);

            }

            ParametersType::Bridge => {

                let bridges = metrics::exit_addresses(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(ExitNode::from)

                    .collect();



                response.relays(vec![]);

                response.bridges(bridges);

            }

        },

        None => {

            let relays = metrics::exit_addresses(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(ExitNode::from)

                .collect();

            let bridges = metrics::exit_addresses(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(ExitNode::from)

                .collect();

            response.bridges(bridges);

            response.relays(relays);

        }

    }

    let exit_addresses = exit_addresses.into_iter().map(ExitNode::from).collect();

    response.relays(exit_addresses);



    let exit_node = response.build().map_err(ErrorInternalServerError)?;

src/handlers/summary.rs

+13 −30
Original line number Diff line number Diff line
@@ -20,9 +20,15 @@ pub async fn get_summary( 
    let mut response = lock.get();

    drop(lock);



    let relay_published = metrics::relays_published(&pg).await.map_err(ErrorInternalServerError)?;

    let bridges_published =

        metrics::bridges_published(&pg).await.map_err(ErrorInternalServerError)?;

    let res = tokio::try_join!(

        metrics::relays_published(&pg),

        metrics::bridges_published(&pg),

        metrics::relay_summary(&pg, &params),

        metrics::bridges_summary(&pg, &params)

    )

    .map_err(ErrorInternalServerError)?;



    let (relay_published, bridges_published, relays, bridges) = res;



    response.relays_published(relay_published);

    response.bridges_published(bridges_published);
@@ -34,42 +40,19 @@ pub async fn get_summary( 
    match params.r#type {

        Some(t) => match t {

            ParametersType::Relay => {

                let relays = metrics::relay_summary(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(RelaySummary::from)

                    .collect();



                let relays = relays.into_iter().map(RelaySummary::from).collect();

                response.relays(relays);

                response.bridges(vec![]);

            }

            ParametersType::Bridge => {

                let bridges = metrics::bridges_summary(&pg, &params)

                    .await

                    .map_err(ErrorInternalServerError)?

                    .into_iter()

                    .map(BridgeSummary::from)

                    .collect();



                let bridges = bridges.into_iter().map(BridgeSummary::from).collect();

                response.relays(vec![]);

                response.bridges(bridges);

            }

        },

        None => {

            let relays = metrics::relay_summary(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(RelaySummary::from)

                .collect();

            let bridges = metrics::bridges_summary(&pg, &params)

                .await

                .map_err(ErrorInternalServerError)?

                .into_iter()

                .map(BridgeSummary::from)

                .collect();



            let relays = relays.into_iter().map(RelaySummary::from).collect();

            let bridges = bridges.into_iter().map(BridgeSummary::from).collect();

            response.relays(relays);

            response.bridges(bridges);

        }