Refactoring

Author: robsdedude

neo4j/src/driver/home_db_cache.rs

@@ -226,19 +226,21 @@ impl SessionAuthKey {
 
 impl HomeDbCacheKey {
     pub(super) fn new(user: Option<&Arc<String>>, session_auth: Option<&Arc<AuthToken>>) -> Self {
-        if let Some(user) = user {
-            HomeDbCacheKey::FixedUser(Arc::clone(user))
-        } else if let Some(auth) = session_auth {
-            if let Some(ValueSend::String(scheme)) = auth.data.get("scheme") {
-                if scheme == "basic" {
-                    if let Some(ValueSend::String(user)) = auth.data.get("principal") {
-                        return HomeDbCacheKey::FixedUser(Arc::new(user.clone()));
-                    }
-                }
+        fn get_basic_auth_principal(auth: &AuthToken) -> Option<&str> {
+            let scheme = auth.data.get("scheme")?.as_string()?.as_str();
+            if scheme != "basic" {
+                return None;
             }
-            HomeDbCacheKey::SessionAuth(SessionAuthKey(Arc::clone(auth)))
-        } else {
-            HomeDbCacheKey::DriverUser
+            Some(auth.data.get("principal")?.as_string()?.as_str())
+        }
+
+        match (user, session_auth) {
+            (Some(user), _) => HomeDbCacheKey::FixedUser(Arc::clone(user)),
+            (None, Some(auth)) => match get_basic_auth_principal(auth) {
+                Some(user) => HomeDbCacheKey::FixedUser(Arc::new(user.to_string())),
+                None => HomeDbCacheKey::SessionAuth(SessionAuthKey(Arc::clone(auth))),
+            },
+            (None, None) => HomeDbCacheKey::DriverUser,
         }
     }
 }

neo4j/src/driver/io/bolt.rs

@@ -523,15 +523,15 @@ trait BoltProtocol: Debug {
 #[enum_dispatch(BoltProtocol)]
 #[derive(Debug)]
 enum BoltProtocolVersion {
-    V5x8(Bolt5x8<Bolt5x8StructTranslator>),
-    V5x7(Bolt5x7<Bolt5x7StructTranslator>),
-    V5x6(Bolt5x6<Bolt5x6StructTranslator>),
-    V5x4(Bolt5x4<Bolt5x4StructTranslator>),
-    V5x3(Bolt5x3<Bolt5x3StructTranslator>),
-    V5x2(Bolt5x2<Bolt5x2StructTranslator>),
-    V5x1(Bolt5x1<Bolt5x1StructTranslator>),
-    V5x0(Bolt5x0<Bolt5x0StructTranslator>),
     V4x4(Bolt4x4<Bolt4x4StructTranslator>),
+    V5x0(Bolt5x0<Bolt5x0StructTranslator>),
+    V5x1(Bolt5x1<Bolt5x1StructTranslator>),
+    V5x2(Bolt5x2<Bolt5x2StructTranslator>),
+    V5x3(Bolt5x3<Bolt5x3StructTranslator>),
+    V5x4(Bolt5x4<Bolt5x4StructTranslator>),
+    V5x6(Bolt5x6<Bolt5x6StructTranslator>),
+    V5x7(Bolt5x7<Bolt5x7StructTranslator>),
+    V5x8(Bolt5x8<Bolt5x8StructTranslator>),
 }
 
 #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]

neo4j/src/driver/io/bolt/bolt5x0/protocol.rs

@@ -709,12 +709,7 @@ impl<T: BoltStructTranslator> BoltProtocol for Bolt5x0<T> {
 
         Self::write_mode_entry(log_buf.as_mut(), &mut serializer, &mut dbg_serializer, mode)?;
 
-        Self::write_db_entry(
-            log_buf.as_mut(),
-            &mut serializer,
-            &mut dbg_serializer,
-            db.as_deref().map(String::as_str),
-        )?;
+        Self::write_db_entry(log_buf.as_mut(), &mut serializer, &mut dbg_serializer, db)?;
 
         Self::write_imp_user_entry(
             log_buf.as_mut(),

neo4j/src/driver/io/bolt/bolt5x2/protocol.rs

@@ -300,12 +300,7 @@ impl<T: BoltStructTranslator> BoltProtocol for Bolt5x2<T> {
             mode,
         )?;
 
-        Bolt5x0::<T>::write_db_entry(
-            log_buf.as_mut(),
-            &mut serializer,
-            &mut dbg_serializer,
-            db.as_deref().map(String::as_str),
-        )?;
+        Bolt5x0::<T>::write_db_entry(log_buf.as_mut(), &mut serializer, &mut dbg_serializer, db)?;
 
         Bolt5x0::<T>::write_imp_user_entry(
             log_buf.as_mut(),

neo4j/src/driver/io/bolt/message_parameters.rs

@@ -84,7 +84,7 @@ pub(crate) struct RunParameters<'a, KP: Borrow<str> + Debug, KM: Borrow<str> + D
     pub(super) tx_timeout: Option<i64>,
     pub(super) tx_metadata: Option<&'a HashMap<KM, ValueSend>>,
     pub(super) mode: Option<&'a str>,
-    pub(super) db: Option<Arc<String>>,
+    pub(super) db: Option<&'a str>,
     pub(super) imp_user: Option<&'a str>,
     pub(super) notification_filter: Option<&'a NotificationFilter>,
 }
@@ -98,7 +98,7 @@ impl<'a, KP: Borrow<str> + Debug, KM: Borrow<str> + Debug> RunParameters<'a, KP,
         tx_timeout: Option<i64>,
         tx_metadata: Option<&'a HashMap<KM, ValueSend>>,
         mode: Option<&'a str>,
-        db: Option<Arc<String>>,
+        db: Option<&'a str>,
         imp_user: Option<&'a str>,
         notification_filter: &'a NotificationFilter,
     ) -> Self {

neo4j/src/driver/io/pool.rs

@@ -503,7 +503,7 @@ impl RoutingPool {
     ) -> Result<(RwLockReadGuard<RoutingTables>, Option<Arc<String>>)> {
         let rt_args = args.update_rt_args;
         let db_key = rt_args.rt_key();
-        let db_name = RefCell::new(rt_args.db_name());
+        let db_name = RefCell::new(rt_args.db_request());
         let db_name_ref = &db_name;
         let lock = self.routing_tables.maybe_write(
             |rts| {
@@ -589,19 +589,13 @@ impl RoutingPool {
                     Some(args_db) if !args_db.guess => {
                         let db = Some(Arc::clone(&args_db.db));
                         new_rt.database.clone_from(&db);
-                        debug!("Storing new routing table for {:?}: {:?}", db, new_rt);
-                        rts.insert(db.as_ref().map(Arc::clone), new_rt);
-                        self.clean_up_pools(rts);
-                        db
-                    }
-                    _ => {
-                        let db = new_rt.database.clone();
-                        debug!("Storing new routing table for {:?}: {:?}", db, new_rt);
-                        rts.insert(db.clone(), new_rt);
-                        self.clean_up_pools(rts);
                         db
                     }
+                    _ => new_rt.database.clone(),
                 };
+                debug!("Storing new routing table for {:?}: {:?}", db, new_rt);
+                rts.insert(db.as_ref().map(Arc::clone), new_rt);
+                self.clean_up_pools(rts);
                 if let Some(cb) = args.db_resolution_cb {
                     cb(db.as_ref().map(Arc::clone));
                 }
@@ -916,7 +910,7 @@ impl UpdateRtArgs<'_> {
         })
     }
 
-    fn db_name(&self) -> Option<Arc<String>> {
+    fn db_request(&self) -> Option<Arc<String>> {
         self.db.as_ref().and_then(|db| match db.guess {
             true => None,
             false => Some(Arc::clone(&db.db)),

neo4j/src/driver/session.rs

@@ -169,7 +169,7 @@ impl<'driver> Session<'driver> {
                     builder.timeout.raw(),
                     Some(builder.meta.borrow()),
                     builder.mode.as_protocol_str(),
-                    target_db,
+                    target_db.as_deref().map(String::as_str),
                     self.config
                         .config
                         .as_ref()