rust/hyperswitch
1
0
Fork 0
mirror of https://github.com/juspay/hyperswitch.git synced 2025-10-29 17:19:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(router): update OLTP/OLAP feature flags to be compatible with each other (#389)

Browse Source
This commit is contained in:
Sampras Lopes
2023-01-17 12:02:58 +05:30
committed by GitHub
parent 8baa968ca2
commit a4eaa36034
7 changed files with 201 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@ -989,9 +989,9 @@ dependencies = [
[[package]] [[package]]
name = "concurrent-queue" name = "concurrent-queue"
version = "2.0.0" version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd7bef69dc86e3c610e4e7aed41035e2a7ed12e72dd7530f61327a6579a4390b" checksum = "c278839b831783b70278b14df4d45e1beb1aad306c07bb796637de9a0e323e8e"
dependencies = [ dependencies = [
"crossbeam-utils", "crossbeam-utils",
] ]

6
Makefile
View File

@ -89,4 +89,8 @@ nextest:
# Usage : # Usage :
# make precommit # make precommit
precommit : fmt clippy test precommit : fmt clippy test
hack:
cargo hack check --workspace --each-feature --no-dev-deps

3
crates/router/Cargo.toml
View File

@ -10,12 +10,13 @@ license = "Apache-2.0"
build = "src/build.rs" build = "src/build.rs"
[features] [features]
default = ["kv_store", "stripe"] default = ["kv_store", "stripe", "oltp", "olap"]
kms = ["aws-config", "aws-sdk-kms"] kms = ["aws-config", "aws-sdk-kms"]
basilisk = [] basilisk = []
stripe = ["dep:serde_qs"] stripe = ["dep:serde_qs"]
sandbox = ["kms", "stripe", "basilisk"] sandbox = ["kms", "stripe", "basilisk"]
olap = [] olap = []
oltp = []
production = [] production = []
kv_store = [] kv_store = []

9
crates/router/src/bin/router.rs
View File

@ -32,14 +32,7 @@ async fn main() -> ApplicationResult<()> {
logger::info!("Application started [{:?}] [{:?}]", conf.server, conf.log); logger::info!("Application started [{:?}] [{:?}]", conf.server, conf.log);
#[allow(clippy::expect_used)] #[allow(clippy::expect_used)]
#[cfg(not(feature = "olap"))] let (server, mut state) = router::start_server(conf)
let (server, mut state) = router::start_oltp_server(conf)
.await
.expect("Failed to create the server");
#[allow(clippy::expect_used)]
#[cfg(feature = "olap")]
let (server, mut state) = router::start_olap_server(conf)
.await .await
.expect("Failed to create the server"); .expect("Failed to create the server");

99
crates/router/src/lib.rs
View File

@ -58,8 +58,7 @@ pub mod pii {
pub use masking::*; pub use masking::*;
} }
#[cfg(feature = "olap")] pub fn mk_app(
pub fn mk_olap_app(
state: AppState, state: AppState,
request_body_limit: usize, request_body_limit: usize,
) -> actix_web::App< ) -> actix_web::App<
@ -71,40 +70,54 @@ pub fn mk_olap_app(
InitError = (), InitError = (),
>, >,
> { > {
let application_builder = get_application_builder(request_body_limit); let mut server_app = get_application_builder(request_body_limit);
let mut server_app = application_builder #[cfg(any(feature = "olap", feature = "oltp"))]
.service(routes::Payments::olap_server(state.clone())) {
.service(routes::Customers::olap_server(state.clone())) server_app = server_app
.service(routes::Refunds::olap_server(state.clone())) .service(routes::Payments::server(state.clone()))
.service(routes::Payouts::olap_server(state.clone())) .service(routes::Customers::server(state.clone()))
.service(routes::MerchantAccount::olap_server(state.clone())) .service(routes::Refunds::server(state.clone()))
.service(routes::MerchantConnectorAccount::olap_server(state.clone())) .service(routes::Payouts::server(state.clone()))
.service(routes::Mandates::olap_server(state.clone())); .service(routes::MerchantConnectorAccount::server(state.clone()))
.service(routes::Mandates::server(state.clone()));
}
#[cfg(feature = "oltp")]
{
server_app = server_app
.service(routes::PaymentMethods::server(state.clone()))
.service(routes::EphemeralKey::server(state.clone()))
.service(routes::Webhooks::server(state.clone()));
}
#[cfg(feature = "olap")]
{
server_app = server_app.service(routes::MerchantAccount::server(state.clone()));
}
#[cfg(feature = "stripe")] #[cfg(feature = "stripe")]
{ {
server_app = server_app.service(routes::StripeApis::server(state.clone())); server_app = server_app.service(routes::StripeApis::server(state.clone()));
} }
server_app = server_app.service(routes::Health::olap_server(state)); server_app = server_app.service(routes::Health::server(state));
server_app server_app
} }
/// Starts the OLAP server with only OLAP services /// Starts the server
/// ///
/// # Panics /// # Panics
/// ///
/// Unwrap used because without the value we can't start the server /// Unwrap used because without the value we can't start the server
#[allow(clippy::expect_used, clippy::unwrap_used)] #[allow(clippy::expect_used, clippy::unwrap_used)]
#[cfg(feature = "olap")] pub async fn start_server(conf: settings::Settings) -> ApplicationResult<(Server, AppState)> {
pub async fn start_olap_server(conf: settings::Settings) -> ApplicationResult<(Server, AppState)> {
logger::debug!(startup_config=?conf); logger::debug!(startup_config=?conf);
let server = conf.server.clone(); let server = conf.server.clone();
let state = routes::AppState::new(conf).await; let state = routes::AppState::new(conf).await;
// Cloning to close connections before shutdown // Cloning to close connections before shutdown
let app_state = state.clone(); let app_state = state.clone();
let request_body_limit = server.request_body_limit; let request_body_limit = server.request_body_limit;
let server = actix_web::HttpServer::new(move || mk_olap_app(state.clone(), request_body_limit)) let server = actix_web::HttpServer::new(move || mk_app(state.clone(), request_body_limit))
.bind((server.host.as_str(), server.port))? .bind((server.host.as_str(), server.port))?
.workers(server.workers.unwrap_or_else(num_cpus::get_physical)) .workers(server.workers.unwrap_or_else(num_cpus::get_physical))
.run(); .run();
@ -143,57 +156,3 @@ pub fn get_application_builder(
)) ))
.wrap(cors::cors()) .wrap(cors::cors())
} }
pub fn mk_oltp_app(
state: AppState,
request_body_limit: usize,
) -> actix_web::App<
impl ServiceFactory<
ServiceRequest,
Config = (),
Response = actix_web::dev::ServiceResponse<impl MessageBody>,
Error = actix_web::Error,
InitError = (),
>,
> {
let application_builder = get_application_builder(request_body_limit);
let mut server_app = application_builder
.service(routes::Payments::oltp_server(state.clone()))
.service(routes::Customers::oltp_server(state.clone()))
.service(routes::Refunds::oltp_server(state.clone()))
.service(routes::Payouts::oltp_server(state.clone()))
.service(routes::PaymentMethods::oltp_server(state.clone()))
.service(routes::EphemeralKey::oltp_server(state.clone()))
.service(routes::Webhooks::oltp_server(state.clone()))
.service(routes::MerchantConnectorAccount::oltp_server(state.clone()))
.service(routes::Mandates::oltp_server(state.clone()));
#[cfg(feature = "stripe")]
{
server_app = server_app.service(routes::StripeApis::server(state.clone()));
}
server_app = server_app.service(routes::Health::oltp_server(state));
server_app
}
/// Starts the OLTP server with only OLTP services
///
/// # Panics
///
/// Unwrap used because without the value we can't start the server
#[allow(clippy::expect_used, clippy::unwrap_used)]
pub async fn start_oltp_server(conf: settings::Settings) -> ApplicationResult<(Server, AppState)> {
logger::debug!(startup_config=?conf);
let server = conf.server.clone();
let state = routes::AppState::new(conf).await;
// Cloning to close connections before shutdown
let app_state = state.clone();
let request_body_limit = server.request_body_limit;
let server = actix_web::HttpServer::new(move || mk_oltp_app(state.clone(), request_body_limit))
.bind((server.host.as_str(), server.port))?
.workers(server.workers.unwrap_or_else(num_cpus::get_physical))
.run();
Ok((server, app_state))
}

290
crates/router/src/routes/app.rs
View File

@ -1,9 +1,12 @@
use actix_web::{web, Scope}; use actix_web::{web, Scope};
use super::{ #[cfg(feature = "olap")]
customers::*, ephemeral_key::*, health::*, mandates::*, payment_methods::*, payments::*, use super::admin::*;
payouts::*, refunds::*, webhooks::*, use super::health::*;
}; #[cfg(any(feature = "olap", feature = "oltp"))]
use super::{customers::*, mandates::*, payments::*, payouts::*, refunds::*};
#[cfg(feature = "oltp")]
use super::{ephemeral_key::*, payment_methods::*, webhooks::*};
use crate::{ use crate::{
configs::settings::Settings, configs::settings::Settings,
db::{MockDb, StorageImpl, StorageInterface}, db::{MockDb, StorageImpl, StorageInterface},
@ -43,13 +46,7 @@ impl AppState {
pub struct Health; pub struct Health;
impl Health { impl Health {
pub fn oltp_server(state: AppState) -> Scope { pub fn server(state: AppState) -> Scope {
web::scope("")
.app_data(web::Data::new(state))
.service(web::resource("/health").route(web::get().to(health)))
}
#[cfg(feature = "olap")]
pub fn olap_server(state: AppState) -> Scope {
web::scope("") web::scope("")
.app_data(web::Data::new(state)) .app_data(web::Data::new(state))
.service(web::resource("/health").route(web::get().to(health))) .service(web::resource("/health").route(web::get().to(health)))
@ -58,115 +55,139 @@ impl Health {
pub struct Payments; pub struct Payments;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl Payments { impl Payments {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/payments").app_data(web::Data::new(state));
web::scope("/payments")
.app_data(web::Data::new(state)) #[cfg(feature = "olap")]
.service(web::resource("/list").route(web::get().to(payments_list))) {
} route = route.service(web::resource("/list").route(web::get().to(payments_list)));
pub fn oltp_server(state: AppState) -> Scope { }
// Routes are matched in the order they are declared. #[cfg(feature = "oltp")]
web::scope("/payments") {
.app_data(web::Data::new(state)) route = route
.service(web::resource("").route(web::post().to(payments_create))) .service(web::resource("").route(web::post().to(payments_create)))
.service( .service(
web::resource("/session_tokens").route(web::post().to(payments_connector_session)), web::resource("/session_tokens")
) .route(web::post().to(payments_connector_session)),
.service( )
web::resource("/{payment_id}") .service(
.route(web::get().to(payments_retrieve)) web::resource("/{payment_id}")
.route(web::post().to(payments_update)), .route(web::get().to(payments_retrieve))
) .route(web::post().to(payments_update)),
.service(web::resource("/{payment_id}/confirm").route(web::post().to(payments_confirm))) )
.service(web::resource("/{payment_id}/cancel").route(web::post().to(payments_cancel))) .service(
.service(web::resource("/{payment_id}/capture").route(web::post().to(payments_capture))) web::resource("/{payment_id}/confirm").route(web::post().to(payments_confirm)),
.service( )
web::resource("/start/{payment_id}/{merchant_id}/{attempt_id}") .service(
.route(web::get().to(payments_start)), web::resource("/{payment_id}/cancel").route(web::post().to(payments_cancel)),
) )
.service( .service(
web::resource("/{payment_id}/{merchant_id}/response/{connector}") web::resource("/{payment_id}/capture").route(web::post().to(payments_capture)),
.route(web::get().to(payments_response)), )
) .service(
web::resource("/start/{payment_id}/{merchant_id}/{attempt_id}")
.route(web::get().to(payments_start)),
)
.service(
web::resource("/{payment_id}/{merchant_id}/response/{connector}")
.route(web::get().to(payments_response)),
);
}
route
} }
} }
pub struct Customers; pub struct Customers;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl Customers { impl Customers {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/customers").app_data(web::Data::new(state));
web::scope("/customers")
.app_data(web::Data::new(state)) #[cfg(feature = "olap")]
.service( {
route = route.service(
web::resource("/{customer_id}/mandates") web::resource("/{customer_id}/mandates")
.route(web::get().to(get_customer_mandates)), .route(web::get().to(get_customer_mandates)),
) );
} }
pub fn oltp_server(state: AppState) -> Scope {
web::scope("/customers") #[cfg(feature = "oltp")]
.app_data(web::Data::new(state)) {
.service(web::resource("").route(web::post().to(customers_create))) route = route
.service( .service(web::resource("").route(web::post().to(customers_create)))
web::resource("/{customer_id}") .service(
.route(web::get().to(customers_retrieve)) web::resource("/{customer_id}")
.route(web::post().to(customers_update)) .route(web::get().to(customers_retrieve))
.route(web::delete().to(customers_delete)), .route(web::post().to(customers_update))
) .route(web::delete().to(customers_delete)),
.service( )
web::resource("/{customer_id}/payment_methods") .service(
.route(web::get().to(list_customer_payment_method_api)), web::resource("/{customer_id}/payment_methods")
) .route(web::get().to(list_customer_payment_method_api)),
);
}
route
} }
} }
pub struct Refunds; pub struct Refunds;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl Refunds { impl Refunds {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/refunds").app_data(web::Data::new(state));
web::scope("/refunds")
.app_data(web::Data::new(state)) #[cfg(feature = "olap")]
.service(web::resource("/list").route(web::get().to(refunds_list))) {
} route = route.service(web::resource("/list").route(web::get().to(refunds_list)));
pub fn oltp_server(state: AppState) -> Scope { }
// Routes are matches in the order they are declared. #[cfg(feature = "oltp")]
web::scope("/refunds") {
.app_data(web::Data::new(state)) route = route
.service(web::resource("").route(web::post().to(refunds_create))) .service(web::resource("").route(web::post().to(refunds_create)))
.service( .service(
web::resource("/{id}") web::resource("/{id}")
.route(web::get().to(refunds_retrieve)) .route(web::get().to(refunds_retrieve))
.route(web::post().to(refunds_update)), .route(web::post().to(refunds_update)),
) );
}
route
} }
} }
pub struct Payouts; pub struct Payouts;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl Payouts { impl Payouts {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/payouts").app_data(web::Data::new(state));
web::scope("/payouts")
.app_data(web::Data::new(state)) #[cfg(feature = "olap")]
.service(web::resource("/accounts").route(web::get().to(payouts_accounts))) {
} route =
pub fn oltp_server(state: AppState) -> Scope { route.service(web::resource("/accounts").route(web::get().to(payouts_accounts)));
web::scope("/payouts") }
.app_data(web::Data::new(state)) #[cfg(feature = "oltp")]
.service(web::resource("/create").route(web::post().to(payouts_create))) {
.service(web::resource("/retrieve").route(web::get().to(payouts_retrieve))) route = route
.service(web::resource("/update").route(web::post().to(payouts_update))) .service(web::resource("/create").route(web::post().to(payouts_create)))
.service(web::resource("/reverse").route(web::post().to(payouts_reverse))) .service(web::resource("/retrieve").route(web::get().to(payouts_retrieve)))
.service(web::resource("/cancel").route(web::post().to(payouts_cancel))) .service(web::resource("/update").route(web::post().to(payouts_update)))
.service(web::resource("/reverse").route(web::post().to(payouts_reverse)))
.service(web::resource("/cancel").route(web::post().to(payouts_cancel)));
}
route
} }
} }
pub struct PaymentMethods; pub struct PaymentMethods;
#[cfg(feature = "oltp")]
impl PaymentMethods { impl PaymentMethods {
pub fn oltp_server(state: AppState) -> Scope { pub fn server(state: AppState) -> Scope {
web::scope("/payment_methods") web::scope("/payment_methods")
.app_data(web::Data::new(state)) .app_data(web::Data::new(state))
.service(web::resource("").route(web::post().to(create_payment_method_api))) .service(web::resource("").route(web::post().to(create_payment_method_api)))
@ -181,10 +202,9 @@ impl PaymentMethods {
pub struct MerchantAccount; pub struct MerchantAccount;
#[cfg(feature = "olap")]
impl MerchantAccount { impl MerchantAccount {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope {
use super::admin::*;
web::scope("/accounts") web::scope("/accounts")
.app_data(web::Data::new(state)) .app_data(web::Data::new(state))
.service(web::resource("").route(web::post().to(merchant_account_create))) .service(web::resource("").route(web::post().to(merchant_account_create)))
@ -199,38 +219,43 @@ impl MerchantAccount {
pub struct MerchantConnectorAccount; pub struct MerchantConnectorAccount;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl MerchantConnectorAccount { impl MerchantConnectorAccount {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/account").app_data(web::Data::new(state));
use super::admin::*;
web::scope("/account")
.app_data(web::Data::new(state))
.service(
web::resource("/{merchant_id}/connectors")
.route(web::post().to(payment_connector_create))
.route(web::get().to(payment_connector_list)),
)
.service(
web::resource("/{merchant_id}/connectors/{merchant_connector_id}")
.route(web::get().to(payment_connector_retrieve))
.route(web::post().to(payment_connector_update))
.route(web::delete().to(payment_connector_delete)),
)
}
pub fn oltp_server(state: AppState) -> Scope { #[cfg(feature = "olap")]
web::scope("/account") {
.app_data(web::Data::new(state)) use super::admin::*;
.service(
route = route
.service(
web::resource("/{merchant_id}/connectors")
.route(web::post().to(payment_connector_create))
.route(web::get().to(payment_connector_list)),
)
.service(
web::resource("/{merchant_id}/connectors/{merchant_connector_id}")
.route(web::get().to(payment_connector_retrieve))
.route(web::post().to(payment_connector_update))
.route(web::delete().to(payment_connector_delete)),
);
}
#[cfg(feature = "oltp")]
{
route = route.service(
web::resource("/payment_methods").route(web::get().to(list_payment_method_api)), web::resource("/payment_methods").route(web::get().to(list_payment_method_api)),
) );
}
route
} }
} }
pub struct EphemeralKey; pub struct EphemeralKey;
#[cfg(feature = "oltp")]
impl EphemeralKey { impl EphemeralKey {
pub fn oltp_server(config: AppState) -> Scope { pub fn server(config: AppState) -> Scope {
web::scope("/ephemeral_keys") web::scope("/ephemeral_keys")
.app_data(web::Data::new(config)) .app_data(web::Data::new(config))
.service(web::resource("").route(web::post().to(ephemeral_key_create))) .service(web::resource("").route(web::post().to(ephemeral_key_create)))
@ -240,24 +265,29 @@ impl EphemeralKey {
pub struct Mandates; pub struct Mandates;
#[cfg(any(feature = "olap", feature = "oltp"))]
impl Mandates { impl Mandates {
#[cfg(feature = "olap")] pub fn server(state: AppState) -> Scope {
pub fn olap_server(state: AppState) -> Scope { let mut route = web::scope("/mandates").app_data(web::Data::new(state));
web::scope("/mandates")
.app_data(web::Data::new(state)) #[cfg(feature = "olap")]
.service(web::resource("/{id}").route(web::get().to(get_mandate))) {
} route = route.service(web::resource("/{id}").route(web::get().to(get_mandate)));
pub fn oltp_server(config: AppState) -> Scope { }
web::scope("/mandates") #[cfg(feature = "oltp")]
.app_data(web::Data::new(config)) {
.service(web::resource("/revoke/{id}").route(web::post().to(revoke_mandate))) route =
route.service(web::resource("/revoke/{id}").route(web::post().to(revoke_mandate)));
}
route
} }
} }
pub struct Webhooks; pub struct Webhooks;
#[cfg(feature = "oltp")]
impl Webhooks { impl Webhooks {
pub fn oltp_server(config: AppState) -> Scope { pub fn server(config: AppState) -> Scope {
web::scope("/webhooks") web::scope("/webhooks")
.app_data(web::Data::new(config)) .app_data(web::Data::new(config))
.service( .service(

4
crates/router/tests/utils.rs
View File

@ -20,7 +20,7 @@ static SERVER: OnceCell<bool> = OnceCell::const_new();
async fn spawn_server() -> bool { async fn spawn_server() -> bool {
let conf = Settings::new().expect("invalid settings"); let conf = Settings::new().expect("invalid settings");
let (server, _state) = router::start_oltp_server(conf) let (server, _state) = router::start_server(conf)
.await .await
.expect("failed to create server"); .expect("failed to create server");
@ -49,7 +49,7 @@ pub async fn mk_service(
} }
let app_state = AppState::with_storage(conf, router::db::StorageImpl::Mock).await; let app_state = AppState::with_storage(conf, router::db::StorageImpl::Mock).await;
actix_web::test::init_service(router::mk_oltp_app(app_state, request_body_limit)).await actix_web::test::init_service(router::mk_app(app_state, request_body_limit)).await
} }
pub struct Guest; pub struct Guest;