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

Cargo.lock

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

Makefile

@@ -90,3 +90,7 @@ nextest:
 #	make precommit
 
 precommit : fmt clippy test
+
+
+hack:
+	cargo hack check --workspace --each-feature --no-dev-deps

crates/router/Cargo.toml

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

crates/router/src/bin/router.rs

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

crates/router/src/lib.rs

@@ -58,8 +58,7 @@ pub mod pii {
     pub use masking::*;
 }
 
-#[cfg(feature = "olap")]
-pub fn mk_olap_app(
+pub fn mk_app(
     state: AppState,
     request_body_limit: usize,
 ) -> actix_web::App<
@@ -71,40 +70,54 @@ pub fn mk_olap_app(
         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
-        .service(routes::Payments::olap_server(state.clone()))
-        .service(routes::Customers::olap_server(state.clone()))
-        .service(routes::Refunds::olap_server(state.clone()))
-        .service(routes::Payouts::olap_server(state.clone()))
-        .service(routes::MerchantAccount::olap_server(state.clone()))
-        .service(routes::MerchantConnectorAccount::olap_server(state.clone()))
-        .service(routes::Mandates::olap_server(state.clone()));
+    #[cfg(any(feature = "olap", feature = "oltp"))]
+    {
+        server_app = server_app
+            .service(routes::Payments::server(state.clone()))
+            .service(routes::Customers::server(state.clone()))
+            .service(routes::Refunds::server(state.clone()))
+            .service(routes::Payouts::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")]
     {
         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
 }
 
-/// Starts the OLAP server with only OLAP services
+/// Starts the server
 ///
 /// # Panics
 ///
 ///  Unwrap used because without the value we can't start the server
 #[allow(clippy::expect_used, clippy::unwrap_used)]
-#[cfg(feature = "olap")]
-pub async fn start_olap_server(conf: settings::Settings) -> ApplicationResult<(Server, AppState)> {
+pub async fn start_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_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))?
         .workers(server.workers.unwrap_or_else(num_cpus::get_physical))
         .run();
@@ -143,57 +156,3 @@ pub fn get_application_builder(
         ))
         .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))
-}

crates/router/src/routes/app.rs

@@ -1,9 +1,12 @@
 use actix_web::{web, Scope};
 
-use super::{
-    customers::*, ephemeral_key::*, health::*, mandates::*, payment_methods::*, payments::*,
-    payouts::*, refunds::*, webhooks::*,
-};
+#[cfg(feature = "olap")]
+use super::admin::*;
+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::{
     configs::settings::Settings,
     db::{MockDb, StorageImpl, StorageInterface},
@@ -43,13 +46,7 @@ impl AppState {
 pub struct Health;
 
 impl Health {
-    pub fn oltp_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 {
+    pub fn server(state: AppState) -> Scope {
         web::scope("")
             .app_data(web::Data::new(state))
             .service(web::resource("/health").route(web::get().to(health)))
@@ -58,29 +55,37 @@ impl Health {
 
 pub struct Payments;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl Payments {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/payments").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        web::scope("/payments")
-            .app_data(web::Data::new(state))
-            .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.
-        web::scope("/payments")
-            .app_data(web::Data::new(state))
+        #[cfg(feature = "oltp")]
+        {
+            route = route
                 .service(web::resource("").route(web::post().to(payments_create)))
                 .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}")
                         .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(web::resource("/{payment_id}/capture").route(web::post().to(payments_capture)))
+                .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(
+                    web::resource("/{payment_id}/capture").route(web::post().to(payments_capture)),
+                )
                 .service(
                     web::resource("/start/{payment_id}/{merchant_id}/{attempt_id}")
                         .route(web::get().to(payments_start)),
@@ -88,25 +93,30 @@ impl Payments {
                 .service(
                     web::resource("/{payment_id}/{merchant_id}/response/{connector}")
                         .route(web::get().to(payments_response)),
-            )
+                );
+        }
+        route
     }
 }
 
 pub struct Customers;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl Customers {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/customers").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        web::scope("/customers")
-            .app_data(web::Data::new(state))
-            .service(
+        {
+            route = route.service(
                 web::resource("/{customer_id}/mandates")
                     .route(web::get().to(get_customer_mandates)),
-            )
+            );
         }
-    pub fn oltp_server(state: AppState) -> Scope {
-        web::scope("/customers")
-            .app_data(web::Data::new(state))
+
+        #[cfg(feature = "oltp")]
+        {
+            route = route
                 .service(web::resource("").route(web::post().to(customers_create)))
                 .service(
                     web::resource("/{customer_id}")
@@ -117,56 +127,67 @@ impl Customers {
                 .service(
                     web::resource("/{customer_id}/payment_methods")
                         .route(web::get().to(list_customer_payment_method_api)),
-            )
+                );
+        }
+        route
     }
 }
 
 pub struct Refunds;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl Refunds {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/refunds").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        web::scope("/refunds")
-            .app_data(web::Data::new(state))
-            .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.
-        web::scope("/refunds")
-            .app_data(web::Data::new(state))
+        #[cfg(feature = "oltp")]
+        {
+            route = route
                 .service(web::resource("").route(web::post().to(refunds_create)))
                 .service(
                     web::resource("/{id}")
                         .route(web::get().to(refunds_retrieve))
                         .route(web::post().to(refunds_update)),
-            )
+                );
+        }
+        route
     }
 }
 
 pub struct Payouts;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl Payouts {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/payouts").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        web::scope("/payouts")
-            .app_data(web::Data::new(state))
-            .service(web::resource("/accounts").route(web::get().to(payouts_accounts)))
+        {
+            route =
+                route.service(web::resource("/accounts").route(web::get().to(payouts_accounts)));
         }
-    pub fn oltp_server(state: AppState) -> Scope {
-        web::scope("/payouts")
-            .app_data(web::Data::new(state))
+        #[cfg(feature = "oltp")]
+        {
+            route = route
                 .service(web::resource("/create").route(web::post().to(payouts_create)))
                 .service(web::resource("/retrieve").route(web::get().to(payouts_retrieve)))
                 .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)))
+                .service(web::resource("/cancel").route(web::post().to(payouts_cancel)));
+        }
+        route
     }
 }
 
 pub struct PaymentMethods;
 
+#[cfg(feature = "oltp")]
 impl PaymentMethods {
-    pub fn oltp_server(state: AppState) -> Scope {
+    pub fn server(state: AppState) -> Scope {
         web::scope("/payment_methods")
             .app_data(web::Data::new(state))
             .service(web::resource("").route(web::post().to(create_payment_method_api)))
@@ -181,10 +202,9 @@ impl PaymentMethods {
 
 pub struct MerchantAccount;
 
-impl MerchantAccount {
 #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        use super::admin::*;
+impl MerchantAccount {
+    pub fn server(state: AppState) -> Scope {
         web::scope("/accounts")
             .app_data(web::Data::new(state))
             .service(web::resource("").route(web::post().to(merchant_account_create)))
@@ -199,12 +219,16 @@ impl MerchantAccount {
 
 pub struct MerchantConnectorAccount;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl MerchantConnectorAccount {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/account").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
+        {
             use super::admin::*;
-        web::scope("/account")
-            .app_data(web::Data::new(state))
+
+            route = route
                 .service(
                     web::resource("/{merchant_id}/connectors")
                         .route(web::post().to(payment_connector_create))
@@ -215,22 +239,23 @@ impl MerchantConnectorAccount {
                         .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 {
-        web::scope("/account")
-            .app_data(web::Data::new(state))
-            .service(
+        #[cfg(feature = "oltp")]
+        {
+            route = route.service(
                 web::resource("/payment_methods").route(web::get().to(list_payment_method_api)),
-            )
+            );
+        }
+        route
     }
 }
 
 pub struct EphemeralKey;
 
+#[cfg(feature = "oltp")]
 impl EphemeralKey {
-    pub fn oltp_server(config: AppState) -> Scope {
+    pub fn server(config: AppState) -> Scope {
         web::scope("/ephemeral_keys")
             .app_data(web::Data::new(config))
             .service(web::resource("").route(web::post().to(ephemeral_key_create)))
@@ -240,24 +265,29 @@ impl EphemeralKey {
 
 pub struct Mandates;
 
+#[cfg(any(feature = "olap", feature = "oltp"))]
 impl Mandates {
+    pub fn server(state: AppState) -> Scope {
+        let mut route = web::scope("/mandates").app_data(web::Data::new(state));
+
         #[cfg(feature = "olap")]
-    pub fn olap_server(state: AppState) -> Scope {
-        web::scope("/mandates")
-            .app_data(web::Data::new(state))
-            .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")
-            .app_data(web::Data::new(config))
-            .service(web::resource("/revoke/{id}").route(web::post().to(revoke_mandate)))
+        #[cfg(feature = "oltp")]
+        {
+            route =
+                route.service(web::resource("/revoke/{id}").route(web::post().to(revoke_mandate)));
+        }
+        route
     }
 }
 
 pub struct Webhooks;
 
+#[cfg(feature = "oltp")]
 impl Webhooks {
-    pub fn oltp_server(config: AppState) -> Scope {
+    pub fn server(config: AppState) -> Scope {
         web::scope("/webhooks")
             .app_data(web::Data::new(config))
             .service(

crates/router/tests/utils.rs

@@ -20,7 +20,7 @@ static SERVER: OnceCell<bool> = OnceCell::const_new();
 
 async fn spawn_server() -> bool {
     let conf = Settings::new().expect("invalid settings");
-    let (server, _state) = router::start_oltp_server(conf)
+    let (server, _state) = router::start_server(conf)
         .await
         .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;
-    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;