move [NonError]QueryResponse to response module

Author: wprzytula

scylla/src/client/pager.rs

@@ -32,12 +32,13 @@ use crate::deserialize::DeserializeOwnedRow;
 use crate::errors::ProtocolError;
 use crate::errors::{QueryError, UserRequestError};
 use crate::frame::response::result;
-use crate::network::{Connection, NonErrorQueryResponse, QueryResponse};
+use crate::network::Connection;
 use crate::observability::driver_tracing::RequestSpan;
 use crate::observability::history::{self, HistoryListener};
 use crate::observability::metrics::Metrics;
 use crate::policies::load_balancing::{self, RoutingInfo};
 use crate::policies::retry::{QueryInfo, RetryDecision, RetrySession};
+use crate::response::{NonErrorQueryResponse, QueryResponse};
 use crate::statement::{prepared_statement::PreparedStatement, query::Query};
 use crate::transport::query_result::ColumnSpecs;
 use tracing::{trace, trace_span, warn, Instrument};

scylla/src/client/session.rs

@@ -18,12 +18,9 @@ use crate::errors::{
     BadQuery, NewSessionError, ProtocolError, QueryError, TracingProtocolError, UserRequestError,
 };
 use crate::frame::response::result;
-use crate::network::PoolConfig;
 #[cfg(feature = "ssl")]
 use crate::network::SslConfig;
-use crate::network::{
-    Connection, ConnectionConfig, NonErrorQueryResponse, QueryResponse, VerifiedKeyspaceName,
-};
+use crate::network::{Connection, ConnectionConfig, PoolConfig, VerifiedKeyspaceName};
 use crate::observability::driver_tracing::RequestSpan;
 use crate::observability::history::{self, HistoryListener};
 use crate::observability::metrics::Metrics;
@@ -35,6 +32,7 @@ use crate::policies::retry::{QueryInfo, RetryDecision, RetrySession};
 use crate::policies::speculative_execution;
 use crate::prepared_statement::PreparedStatement;
 use crate::query::Query;
+use crate::response::{NonErrorQueryResponse, QueryResponse};
 use crate::routing::partitioner::PartitionerName;
 use crate::routing::Shard;
 use crate::statement::StatementConfig;

scylla/src/network/connection.rs

@@ -17,12 +17,13 @@ use crate::frame::protocol_features::ProtocolFeatures;
 use crate::frame::{
     self,
     request::{self, batch, execute, query, register, SerializableRequest},
-    response::{event::Event, result, NonErrorResponse, Response, ResponseOpcode},
+    response::{event::Event, result, Response, ResponseOpcode},
     server_event_type::EventType,
     FrameParams, SerializedRequest,
 };
 use crate::policies::address_translator::AddressTranslator;
 use crate::query::Query;
+use crate::response::{NonErrorAuthResponse, NonErrorStartupResponse, QueryResponse};
 use crate::routing::locator::tablets::{RawTablet, TabletParsingError};
 use crate::routing::{Shard, ShardInfo, Sharder};
 use crate::statement::prepared_statement::PreparedStatement;
@@ -208,105 +209,6 @@ struct TaskResponse {
     body: Bytes,
 }
 
-pub(crate) struct QueryResponse {
-    pub(crate) response: Response,
-    pub(crate) tracing_id: Option<Uuid>,
-    pub(crate) warnings: Vec<String>,
-    #[allow(dead_code)] // This is not exposed to user (yet?)
-    pub(crate) custom_payload: Option<HashMap<String, Bytes>>,
-}
-
-// A QueryResponse in which response can not be Response::Error
-pub(crate) struct NonErrorQueryResponse {
-    pub(crate) response: NonErrorResponse,
-    pub(crate) tracing_id: Option<Uuid>,
-    pub(crate) warnings: Vec<String>,
-}
-
-impl QueryResponse {
-    pub(crate) fn into_non_error_query_response(
-        self,
-    ) -> Result<NonErrorQueryResponse, UserRequestError> {
-        Ok(NonErrorQueryResponse {
-            response: self.response.into_non_error_response()?,
-            tracing_id: self.tracing_id,
-            warnings: self.warnings,
-        })
-    }
-
-    pub(crate) fn into_query_result_and_paging_state(
-        self,
-    ) -> Result<(QueryResult, PagingStateResponse), UserRequestError> {
-        self.into_non_error_query_response()?
-            .into_query_result_and_paging_state()
-    }
-
-    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
-        self.into_non_error_query_response()?.into_query_result()
-    }
-}
-
-impl NonErrorQueryResponse {
-    pub(crate) fn as_set_keyspace(&self) -> Option<&result::SetKeyspace> {
-        match &self.response {
-            NonErrorResponse::Result(result::Result::SetKeyspace(sk)) => Some(sk),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn as_schema_change(&self) -> Option<&result::SchemaChange> {
-        match &self.response {
-            NonErrorResponse::Result(result::Result::SchemaChange(sc)) => Some(sc),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn into_query_result_and_paging_state(
-        self,
-    ) -> Result<(QueryResult, PagingStateResponse), UserRequestError> {
-        let (raw_rows, paging_state_response) = match self.response {
-            NonErrorResponse::Result(result::Result::Rows((rs, paging_state_response))) => {
-                (Some(rs), paging_state_response)
-            }
-            NonErrorResponse::Result(_) => (None, PagingStateResponse::NoMorePages),
-            _ => {
-                return Err(UserRequestError::UnexpectedResponse(
-                    self.response.to_response_kind(),
-                ))
-            }
-        };
-
-        Ok((
-            QueryResult::new(raw_rows, self.tracing_id, self.warnings),
-            paging_state_response,
-        ))
-    }
-
-    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
-        let (result, paging_state) = self.into_query_result_and_paging_state()?;
-
-        if !paging_state.finished() {
-            error!(
-                "Internal driver API misuse or a server bug: nonfinished paging state\
-                would be discarded by `NonErrorQueryResponse::into_query_result`"
-            );
-            return Err(ProtocolError::NonfinishedPagingState.into());
-        }
-
-        Ok(result)
-    }
-}
-
-pub(crate) enum NonErrorStartupResponse {
-    Ready,
-    Authenticate(response::authenticate::Authenticate),
-}
-
-pub(crate) enum NonErrorAuthResponse {
-    AuthChallenge(response::authenticate::AuthChallenge),
-    AuthSuccess(response::authenticate::AuthSuccess),
-}
-
 #[cfg(feature = "ssl")]
 mod ssl_config {
     use openssl::{

scylla/src/network/mod.rs

@@ -7,9 +7,7 @@
 mod connection;
 #[cfg(feature = "ssl")]
 pub(crate) use connection::SslConfig;
-pub(crate) use connection::{
-    Connection, ConnectionConfig, NonErrorQueryResponse, QueryResponse, VerifiedKeyspaceName,
-};
+pub(crate) use connection::{Connection, ConnectionConfig, VerifiedKeyspaceName};
 
 mod connection_pool;
 

scylla/src/response/mod.rs

@@ -1 +1,5 @@
+mod request_response;
 
+pub(crate) use request_response::{
+    NonErrorAuthResponse, NonErrorQueryResponse, NonErrorStartupResponse, QueryResponse,
+};

scylla/src/response/request_response.rs

@@ -0,0 +1,110 @@
+use std::collections::HashMap;
+
+use bytes::Bytes;
+use scylla_cql::frame::request::query::PagingStateResponse;
+use scylla_cql::frame::response::{NonErrorResponse, Response};
+use tracing::error;
+use uuid::Uuid;
+
+use crate::errors::{ProtocolError, QueryError, UserRequestError};
+use crate::frame::response::{self, result};
+use crate::QueryResult;
+
+pub(crate) struct QueryResponse {
+    pub(crate) response: Response,
+    pub(crate) tracing_id: Option<Uuid>,
+    pub(crate) warnings: Vec<String>,
+    #[allow(dead_code)] // This is not exposed to user (yet?)
+    pub(crate) custom_payload: Option<HashMap<String, Bytes>>,
+}
+
+// A QueryResponse in which response can not be Response::Error
+pub(crate) struct NonErrorQueryResponse {
+    pub(crate) response: NonErrorResponse,
+    pub(crate) tracing_id: Option<Uuid>,
+    pub(crate) warnings: Vec<String>,
+}
+
+impl QueryResponse {
+    pub(crate) fn into_non_error_query_response(
+        self,
+    ) -> Result<NonErrorQueryResponse, UserRequestError> {
+        Ok(NonErrorQueryResponse {
+            response: self.response.into_non_error_response()?,
+            tracing_id: self.tracing_id,
+            warnings: self.warnings,
+        })
+    }
+
+    pub(crate) fn into_query_result_and_paging_state(
+        self,
+    ) -> Result<(QueryResult, PagingStateResponse), UserRequestError> {
+        self.into_non_error_query_response()?
+            .into_query_result_and_paging_state()
+    }
+
+    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
+        self.into_non_error_query_response()?.into_query_result()
+    }
+}
+
+impl NonErrorQueryResponse {
+    pub(crate) fn as_set_keyspace(&self) -> Option<&result::SetKeyspace> {
+        match &self.response {
+            NonErrorResponse::Result(result::Result::SetKeyspace(sk)) => Some(sk),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn as_schema_change(&self) -> Option<&result::SchemaChange> {
+        match &self.response {
+            NonErrorResponse::Result(result::Result::SchemaChange(sc)) => Some(sc),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn into_query_result_and_paging_state(
+        self,
+    ) -> Result<(QueryResult, PagingStateResponse), UserRequestError> {
+        let (raw_rows, paging_state_response) = match self.response {
+            NonErrorResponse::Result(result::Result::Rows((rs, paging_state_response))) => {
+                (Some(rs), paging_state_response)
+            }
+            NonErrorResponse::Result(_) => (None, PagingStateResponse::NoMorePages),
+            _ => {
+                return Err(UserRequestError::UnexpectedResponse(
+                    self.response.to_response_kind(),
+                ))
+            }
+        };
+
+        Ok((
+            QueryResult::new(raw_rows, self.tracing_id, self.warnings),
+            paging_state_response,
+        ))
+    }
+
+    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
+        let (result, paging_state) = self.into_query_result_and_paging_state()?;
+
+        if !paging_state.finished() {
+            error!(
+                "Internal driver API misuse or a server bug: nonfinished paging state\
+                would be discarded by `NonErrorQueryResponse::into_query_result`"
+            );
+            return Err(ProtocolError::NonfinishedPagingState.into());
+        }
+
+        Ok(result)
+    }
+}
+
+pub(crate) enum NonErrorStartupResponse {
+    Ready,
+    Authenticate(response::authenticate::Authenticate),
+}
+
+pub(crate) enum NonErrorAuthResponse {
+    AuthChallenge(response::authenticate::AuthChallenge),
+    AuthSuccess(response::authenticate::AuthSuccess),
+}