connection: unpub internal types

A number of types in `connection` module were `pub`, but nonetheless
intended for internal usage only. They are unpub'd along with their
methods, including:
- `Connection`,
- `QueryResponse`,
- `NonErrorQueryResponse`,
- `ErrorReceiver` type alias,
- `VerifiedKeyspaceName`.

`connection` module was not public, and the above types were not
reexported anywhere, so no breaking changes incurred.

Author: wprzytula

scylla/src/transport/connection.rs

@@ -75,7 +75,7 @@ const LOCAL_VERSION: &str = "SELECT schema_version FROM system.local WHERE key='
 const OLD_ORPHAN_COUNT_THRESHOLD: usize = 1024;
 const OLD_AGE_ORPHAN_THRESHOLD: std::time::Duration = std::time::Duration::from_secs(1);
 
-pub struct Connection {
+pub(crate) struct Connection {
     _worker_handle: RemoteHandle<()>,
 
     connect_address: SocketAddr,
@@ -210,49 +210,49 @@ struct TaskResponse {
     body: Bytes,
 }
 
-pub struct QueryResponse {
-    pub response: Response,
-    pub tracing_id: Option<Uuid>,
-    pub warnings: Vec<String>,
+pub(crate) struct QueryResponse {
+    pub(crate) response: Response,
+    pub(crate) tracing_id: Option<Uuid>,
+    pub(crate) warnings: Vec<String>,
 }
 
 // A QueryResponse in which response can not be Response::Error
-pub struct NonErrorQueryResponse {
-    pub response: NonErrorResponse,
-    pub tracing_id: Option<Uuid>,
-    pub warnings: Vec<String>,
+pub(crate) struct NonErrorQueryResponse {
+    pub(crate) response: NonErrorResponse,
+    pub(crate) tracing_id: Option<Uuid>,
+    pub(crate) warnings: Vec<String>,
 }
 
 impl QueryResponse {
-    pub fn into_non_error_query_response(self) -> Result<NonErrorQueryResponse, QueryError> {
+    pub(crate) fn into_non_error_query_response(self) -> Result<NonErrorQueryResponse, QueryError> {
         Ok(NonErrorQueryResponse {
             response: self.response.into_non_error_response()?,
             tracing_id: self.tracing_id,
             warnings: self.warnings,
         })
     }
 
-    pub fn into_query_result(self) -> Result<QueryResult, QueryError> {
+    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
         self.into_non_error_query_response()?.into_query_result()
     }
 }
 
 impl NonErrorQueryResponse {
-    pub fn as_set_keyspace(&self) -> Option<&result::SetKeyspace> {
+    pub(crate) fn as_set_keyspace(&self) -> Option<&result::SetKeyspace> {
         match &self.response {
             NonErrorResponse::Result(result::Result::SetKeyspace(sk)) => Some(sk),
             _ => None,
         }
     }
 
-    pub fn as_schema_change(&self) -> Option<&result::SchemaChange> {
+    pub(crate) fn as_schema_change(&self) -> Option<&result::SchemaChange> {
         match &self.response {
             NonErrorResponse::Result(result::Result::SchemaChange(sc)) => Some(sc),
             _ => None,
         }
     }
 
-    pub fn into_query_result(self) -> Result<QueryResult, QueryError> {
+    pub(crate) fn into_query_result(self) -> Result<QueryResult, QueryError> {
         let (rows, paging_state, col_specs, serialized_size) = match self.response {
             NonErrorResponse::Result(result::Result::Rows(rs)) => (
                 Some(rs.rows),
@@ -407,11 +407,11 @@ impl ConnectionConfig {
 }
 
 // Used to listen for fatal error in connection
-pub type ErrorReceiver = tokio::sync::oneshot::Receiver<QueryError>;
+pub(crate) type ErrorReceiver = tokio::sync::oneshot::Receiver<QueryError>;
 
 impl Connection {
     // Returns new connection and ErrorReceiver which can be used to wait for a fatal error
-    pub async fn new(
+    pub(crate) async fn new(
         addr: SocketAddr,
         source_port: Option<u16>,
         config: ConnectionConfig,
@@ -514,21 +514,24 @@ impl Connection {
         Ok((connection, error_receiver))
     }
 
-    pub async fn startup(&self, options: HashMap<String, String>) -> Result<Response, QueryError> {
+    pub(crate) async fn startup(
+        &self,
+        options: HashMap<String, String>,
+    ) -> Result<Response, QueryError> {
         Ok(self
             .send_request(&request::Startup { options }, false, false)
             .await?
             .response)
     }
 
-    pub async fn get_options(&self) -> Result<Response, QueryError> {
+    pub(crate) async fn get_options(&self) -> Result<Response, QueryError> {
         Ok(self
             .send_request(&request::Options {}, false, false)
             .await?
             .response)
     }
 
-    pub async fn prepare(&self, query: &Query) -> Result<PreparedStatement, QueryError> {
+    pub(crate) async fn prepare(&self, query: &Query) -> Result<PreparedStatement, QueryError> {
         let query_response = self
             .send_request(
                 &request::Prepare {
@@ -564,7 +567,7 @@ impl Connection {
         Ok(prepared_statement)
     }
 
-    async fn reprepare(
+    pub(crate) async fn reprepare(
         &self,
         query: impl Into<Query>,
         previous_prepared: &PreparedStatement,
@@ -582,15 +585,15 @@ impl Connection {
         }
     }
 
-    pub async fn authenticate_response(
+    pub(crate) async fn authenticate_response(
         &self,
         response: Option<Vec<u8>>,
     ) -> Result<QueryResponse, QueryError> {
         self.send_request(&request::AuthResponse { response }, false, false)
             .await
     }
 
-    pub async fn query_single_page(
+    pub(crate) async fn query_single_page(
         &self,
         query: impl Into<Query>,
         values: impl ValueList,
@@ -612,7 +615,7 @@ impl Connection {
         .await
     }
 
-    pub async fn query_single_page_with_consistency(
+    pub(crate) async fn query_single_page_with_consistency(
         &self,
         query: impl Into<Query>,
         values: impl ValueList,
@@ -625,7 +628,7 @@ impl Connection {
             .into_query_result()
     }
 
-    pub async fn query(
+    pub(crate) async fn query(
         &self,
         query: &Query,
         values: impl ValueList,
@@ -644,7 +647,7 @@ impl Connection {
         .await
     }
 
-    pub async fn query_with_consistency(
+    pub(crate) async fn query_with_consistency(
         &self,
         query: &Query,
         values: impl ValueList,
@@ -670,7 +673,7 @@ impl Connection {
             .await
     }
 
-    pub async fn execute_with_consistency(
+    pub(crate) async fn execute_with_consistency(
         &self,
         prepared_statement: &PreparedStatement,
         values: impl ValueList,
@@ -737,7 +740,7 @@ impl Connection {
     }
 
     #[allow(dead_code)]
-    pub async fn batch(
+    pub(crate) async fn batch(
         &self,
         batch: &Batch,
         values: impl BatchValues,
@@ -753,7 +756,7 @@ impl Connection {
         .await
     }
 
-    pub async fn batch_with_consistency(
+    pub(crate) async fn batch_with_consistency(
         &self,
         batch: &Batch,
         values: impl BatchValues,
@@ -803,7 +806,7 @@ impl Connection {
         }
     }
 
-    pub async fn use_keyspace(
+    pub(crate) async fn use_keyspace(
         &self,
         keyspace_name: &VerifiedKeyspaceName,
     ) -> Result<(), QueryError> {
@@ -856,7 +859,7 @@ impl Connection {
         }
     }
 
-    pub async fn fetch_schema_version(&self) -> Result<Uuid, QueryError> {
+    pub(crate) async fn fetch_schema_version(&self) -> Result<Uuid, QueryError> {
         let (version_id,): (Uuid,) = self
             .query_single_page(LOCAL_VERSION, &[])
             .await?
@@ -1283,19 +1286,19 @@ impl Connection {
         })
     }
 
-    pub fn get_shard_info(&self) -> &Option<ShardInfo> {
+    pub(crate) fn get_shard_info(&self) -> &Option<ShardInfo> {
         &self.features.shard_info
     }
 
-    pub fn get_shard_aware_port(&self) -> Option<u16> {
+    pub(crate) fn get_shard_aware_port(&self) -> Option<u16> {
         self.features.shard_aware_port
     }
 
     fn set_features(&mut self, features: ConnectionFeatures) {
         self.features = features;
     }
 
-    pub fn get_connect_address(&self) -> SocketAddr {
+    pub(crate) fn get_connect_address(&self) -> SocketAddr {
         self.connect_address
     }
 }
@@ -1339,7 +1342,7 @@ async fn maybe_translated_addr(
     }
 }
 
-pub async fn open_connection(
+pub(crate) async fn open_connection(
     endpoint: UntranslatedEndpoint,
     source_port: Option<u16>,
     config: ConnectionConfig,
@@ -1355,7 +1358,7 @@ pub async fn open_connection(
     .await
 }
 
-pub async fn open_named_connection(
+pub(crate) async fn open_named_connection(
     addr: SocketAddr,
     source_port: Option<u16>,
     config: ConnectionConfig,
@@ -1684,13 +1687,16 @@ impl StreamIdSet {
 
 /// This type can only hold a valid keyspace name
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct VerifiedKeyspaceName {
+pub(crate) struct VerifiedKeyspaceName {
     name: Arc<String>,
-    pub is_case_sensitive: bool,
+    pub(crate) is_case_sensitive: bool,
 }
 
 impl VerifiedKeyspaceName {
-    pub fn new(keyspace_name: String, case_sensitive: bool) -> Result<Self, BadKeyspaceName> {
+    pub(crate) fn new(
+        keyspace_name: String,
+        case_sensitive: bool,
+    ) -> Result<Self, BadKeyspaceName> {
         Self::verify_keyspace_name_is_valid(&keyspace_name)?;
 
         Ok(VerifiedKeyspaceName {
@@ -1699,7 +1705,7 @@ impl VerifiedKeyspaceName {
         })
     }
 
-    pub fn as_str(&self) -> &str {
+    pub(crate) fn as_str(&self) -> &str {
         self.name.as_str()
     }