use RuntimeOptionsView to access runtime options

Author: analogrelay

sdk/cosmos/azure_data_cosmos_driver/src/driver/cosmos_driver.rs

@@ -13,7 +13,7 @@ use crate::{
         CosmosOperation, DatabaseProperties, DatabaseReference,
     },
     options::{
-        ConnectionPoolOptions, DiagnosticsOptions, DriverOptions, OperationOptions, RuntimeOptions,
+        ConnectionPoolOptions, DiagnosticsOptions, DriverOptions, OperationOptions,
         RuntimeOptionsView, ThroughputControlGroupSnapshot,
     },
 };
@@ -696,11 +696,11 @@ impl CosmosDriver {
     /// Returns `None` if no applicable control group is found.
     pub(crate) fn effective_throughput_control_group(
         &self,
-        effective_options: &RuntimeOptions,
+        effective_options: &RuntimeOptionsView<'_>,
         container: &ContainerReference,
     ) -> Option<ThroughputControlGroupSnapshot> {
         // First, check if an explicit group name is specified in options
-        if let Some(group_name) = &effective_options.throughput_control_group_name {
+        if let Some(group_name) = effective_options.throughput_control_group_name() {
             if let Some(group) = self
                 .runtime
                 .get_throughput_control_group(container, group_name)
@@ -784,21 +784,8 @@ impl CosmosDriver {
         }
         tracing::debug!("operation started");
 
-        // Step 1: Build the runtime options view for layered resolution and
-        // materialize a resolved snapshot for the pipeline.
-        let view = self.runtime_options_view(&options);
-        let effective_options = RuntimeOptions {
-            throughput_control_group_name: view.throughput_control_group_name().cloned(),
-            dedicated_gateway_options: view.dedicated_gateway_options().cloned(),
-            diagnostics_thresholds: view.diagnostics_thresholds().cloned(),
-            end_to_end_latency_policy: view.end_to_end_latency_policy().cloned(),
-            excluded_regions: view.excluded_regions().cloned(),
-            read_consistency_strategy: view.read_consistency_strategy().copied(),
-            content_response_on_write: view.content_response_on_write().copied(),
-            max_failover_retry_count: view.max_failover_retry_count().copied(),
-            max_session_retry_count: view.max_session_retry_count().copied(),
-            endpoint_unavailability_ttl: view.endpoint_unavailability_ttl().copied(),
-        };
+        // Step 1: Build the runtime options view for layered resolution.
+        let effective_options = self.runtime_options_view(&options);
 
         // Step 2: Resolve effective throughput control group (if any).
         // Step 1 transport pipeline does not consume this yet.

sdk/cosmos/azure_data_cosmos_driver/src/driver/pipeline/operation_pipeline.rs

@@ -22,7 +22,7 @@ use crate::{
         AccountEndpoint, ActivityId, CosmosOperation, CosmosResponse, CosmosResponseHeaders,
         Credential, SubStatusCode,
     },
-    options::{OperationOptions, RuntimeOptions},
+    options::{OperationOptions, RuntimeOptionsView},
 };
 
 use super::{
@@ -46,7 +46,7 @@ use crate::driver::transport::{
 pub(crate) async fn execute_operation_pipeline(
     operation: &CosmosOperation,
     _options: &OperationOptions,
-    effective_options: &RuntimeOptions,
+    effective_options: &RuntimeOptionsView<'_>,
     location_state_store: &LocationStateStore,
     transport: &CosmosTransport,
     account_endpoint: &AccountEndpoint,
@@ -59,9 +59,10 @@ pub(crate) async fn execute_operation_pipeline(
 ) -> azure_core::Result<CosmosResponse> {
     let mut diagnostics = diagnostics;
     let location_snapshot = location_state_store.snapshot();
-    let max_failover_retries = effective_options.max_failover_retry_count.unwrap_or(3);
+    let max_failover_retries = effective_options.max_failover_retry_count().copied().unwrap_or(3);
     let max_session_retries = effective_options
-        .max_session_retry_count
+        .max_session_retry_count()
+        .copied()
         .unwrap_or_else(|| {
             // Java SDK parity: 2 for single-write, endpoints.len() for multi-write.
             // Uses the original endpoint count (before unavailability filtering).
@@ -80,17 +81,15 @@ pub(crate) async fn execute_operation_pipeline(
         location_snapshot.account.generation,
         location_snapshot.account.multiple_write_locations_enabled,
         effective_options
-            .excluded_regions
-            .as_ref()
+            .excluded_regions()
             .map(|r| r.0.clone())
             .unwrap_or_default(),
         max_failover_retries,
         max_session_retries,
     );
 
     let deadline = effective_options
-        .end_to_end_latency_policy
-        .as_ref()
+        .end_to_end_latency_policy()
         .map(|p| Instant::now() + p.timeout());
 
     let mut attempt = 0;
@@ -195,8 +194,7 @@ pub(crate) async fn execute_operation_pipeline(
                 if let Some(d) = deadline {
                     if Instant::now() >= d {
                         let timeout_duration = effective_options
-                            .end_to_end_latency_policy
-                            .as_ref()
+                            .end_to_end_latency_policy()
                             .map(|p| p.timeout())
                             .unwrap_or_default();
 
@@ -226,8 +224,7 @@ pub(crate) async fn execute_operation_pipeline(
                 if let Some(d) = deadline {
                     if Instant::now() >= d {
                         let timeout_duration = effective_options
-                            .end_to_end_latency_policy
-                            .as_ref()
+                            .end_to_end_latency_policy()
                             .map(|p| p.timeout())
                             .unwrap_or_default();