Comment out remote calls

Author: aasoni

modules/tpcc/src/new_order.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use crate::{
     district, find_customer_by_id, find_district, find_stock, find_warehouse, item, order_line, pack_order_key,
-    remote::{call_remote_reducer, remote_warehouse_home},
+    remote::{remote_warehouse_home, simulate_remote_call},
     stock, District, Item, OrderLine, Stock, WarehouseId, DISTRICTS_PER_WAREHOUSE, TAX_SCALE,
 };
 use spacetimedb::{log_stopwatch::LogStopwatch, reducer, Identity, ReducerContext, SpacetimeType, Table, Timestamp};
@@ -183,12 +183,19 @@ fn call_remote_order_multiple_items_and_decrement_stock(
     remote_database_identity: Identity,
     input: OrderMultipleItemsInput,
 ) -> Result<Vec<OrderItemOutput>, String> {
-    call_remote_reducer(
+    // call_remote_reducer(
+    //     ctx,
+    //     remote_database_identity,
+    //     "order_multiple_items_and_decrement_stocks",
+    //     &input,
+    // )
+    simulate_remote_call(
         ctx,
         remote_database_identity,
         "order_multiple_items_and_decrement_stocks",
         &input,
-    )
+    )?;
+    Ok(simulated_remote_order_outputs(input))
 }
 
 struct ProcessedNewOrderItem {
@@ -262,6 +269,29 @@ pub struct OrderMultipleItemsInput {
     terminal_warehouse: WarehouseId,
 }
 
+fn simulated_remote_order_outputs(input: OrderMultipleItemsInput) -> Vec<OrderItemOutput> {
+    input
+        .lines
+        .into_iter()
+        .map(|line| simulated_remote_order_output(line, input.district))
+        .collect()
+}
+
+fn simulated_remote_order_output(line: NewOrderLineAndIndex, district: u8) -> OrderItemOutput {
+    let stock_data = if line.line.item_id % 10 == 0 {
+        "SIMULATED ORIGINAL STOCK"
+    } else {
+        "SIMULATED REMOTE STOCK"
+    };
+
+    OrderItemOutput {
+        s_dist: format!("REMOTE-D{district:02}"),
+        s_data: stock_data.to_string(),
+        updated_quantity: adjust_stock_quantity(100, line.line.quantity as i32),
+        index: line.index,
+    }
+}
+
 #[reducer]
 fn order_multiple_items_and_decrement_stocks(
     ctx: &ReducerContext,

modules/tpcc/src/payment.rs

@@ -1,6 +1,6 @@
 use crate::{
     customer, district, find_district, find_warehouse, history,
-    remote::{call_remote_reducer, remote_warehouse_home},
+    remote::{remote_warehouse_home, simulate_remote_call},
     resolve_customer, warehouse, Customer, CustomerSelector, District, History, Warehouse, MAX_C_DATA_LEN,
 };
 use spacetimedb::{
@@ -128,12 +128,19 @@ fn call_remote_resolve_and_update_customer_for_payment(
     remote_database_identity: Identity,
     request: &PaymentRequest,
 ) -> Result<Customer, String> {
-    call_remote_reducer(
+    // call_remote_reducer(
+    //     ctx,
+    //     remote_database_identity,
+    //     "resolve_and_update_customer_for_payment",
+    //     request,
+    // )
+    simulate_remote_call(
         ctx,
         remote_database_identity,
         "resolve_and_update_customer_for_payment",
         request,
-    )
+    )?;
+    Ok(simulated_remote_customer(request))
 }
 
 #[procedure]
@@ -149,6 +156,53 @@ fn process_remote_payment(ctx: &mut ProcedureContext, request: PaymentRequest) -
     })
 }
 
+fn simulated_remote_customer(request: &PaymentRequest) -> Customer {
+    let (customer_id, customer_first, customer_last) = match &request.customer_selector {
+        CustomerSelector::ById(customer_id) => (
+            *customer_id,
+            format!("Remote{customer_id}"),
+            format!("Customer{customer_id}"),
+        ),
+        CustomerSelector::ByLastName(last_name) => (
+            simulated_customer_id_from_last_name(last_name),
+            "Remote".to_string(),
+            last_name.clone(),
+        ),
+    };
+
+    Customer {
+        customer_key: 0,
+        c_w_id: request.customer_warehouse_id,
+        c_d_id: request.customer_district_id,
+        c_id: customer_id,
+        c_first: customer_first,
+        c_middle: "OE".to_string(),
+        c_last: customer_last,
+        c_street_1: "REMOTE".to_string(),
+        c_street_2: "SIMULATED".to_string(),
+        c_city: "REMOTE".to_string(),
+        c_state: "RM".to_string(),
+        c_zip: "000000000".to_string(),
+        c_phone: "0000000000000000".to_string(),
+        c_since: request.now,
+        c_credit: "GC".to_string(),
+        c_credit_lim_cents: 5_000_000,
+        c_discount_bps: 0,
+        c_balance_cents: -request.payment_amount_cents,
+        c_ytd_payment_cents: request.payment_amount_cents,
+        c_payment_cnt: 1,
+        c_delivery_cnt: 0,
+        c_data: "SIMULATED_REMOTE_PAYMENT".to_string(),
+    }
+}
+
+fn simulated_customer_id_from_last_name(last_name: &str) -> u32 {
+    let hash = last_name.bytes().fold(0_u32, |acc, byte| {
+        acc.wrapping_mul(31).wrapping_add(u32::from(byte))
+    });
+    (hash % crate::CUSTOMERS_PER_DISTRICT) + 1
+}
+
 fn update_customer(tx: &ReducerContext, request: &PaymentRequest, customer: Customer) -> Customer {
     let mut updated_customer = Customer {
         c_balance_cents: customer.c_balance_cents - request.payment_amount_cents,

modules/tpcc/src/remote.rs

@@ -4,6 +4,8 @@ use spacetimedb::{
 };
 use spacetimedb_sats::bsatn;
 
+const SIMULATED_REMOTE_CALL_WORK: u32 = 1_000_000;
+
 /// For warehouses not managed by this database, stores the [`Identity`] of the remote database which manages that warehouse.
 ///
 /// Will not have a row present for a warehouse managed by the local database.
@@ -41,6 +43,43 @@ pub fn remote_warehouse_home(ctx: &ReducerContext, warehouse_id: u32) -> Option<
         .map(|row| row.remote_database_home)
 }
 
+pub fn simulate_remote_call<Args>(
+    _ctx: &ReducerContext,
+    database_ident: Identity,
+    reducer_name: &str,
+    args: &Args,
+) -> Result<(), String>
+where
+    Args: SpacetimeType + Serialize,
+{
+    let args = bsatn::to_vec(args).map_err(|e| {
+        format!(
+            "Failed to BSATN-serialize args for simulated remote reducer {reducer_name} on database {database_ident}: {e}"
+        )
+    })?;
+
+    // Hold the reducer busy to approximate a synchronous remote call while we debug the real remote-call path.
+    let mut state = mix_remote_work(0x9E37_79B9_7F4A_7C15 ^ u64::try_from(args.len()).unwrap_or(u64::MAX));
+    for byte in format!("{database_ident}:{reducer_name}").bytes() {
+        state = mix_remote_work(state ^ u64::from(byte));
+    }
+    for &byte in &args {
+        state = mix_remote_work(state ^ u64::from(byte));
+    }
+
+    let rounds = SIMULATED_REMOTE_CALL_WORK.saturating_add(
+        u32::try_from(args.len())
+            .unwrap_or(u32::MAX)
+            .saturating_mul(128),
+    );
+    for _ in 0..rounds {
+        state = mix_remote_work(state);
+    }
+    std::hint::black_box(state);
+    Ok(())
+}
+
+#[allow(dead_code)]
 pub fn call_remote_reducer<Args, Output>(
     _ctx: &ReducerContext,
     database_ident: Identity,
@@ -62,3 +101,11 @@ where
         )
     })
 }
+
+fn mix_remote_work(mut state: u64) -> u64 {
+    state ^= state >> 33;
+    state = state.wrapping_mul(0xFF51_AFD7_ED55_8CCD);
+    state ^= state >> 33;
+    state = state.wrapping_mul(0xC4CE_B9FE_1A85_EC53);
+    state ^ (state >> 33)
+}