server: Stop using ServiceManager to store sessions.

Although it was easier to keep the sessions stored in ServiceManager,
storing them inside the Service makes more sense. Because, the Service is
responsible for handling the sessions just like the collections.

Signed-off-by: Dhanuka Warusadura <dhanuka@gnome.org>

Author: warusadura

server/src/error.rs

@@ -1,5 +1,7 @@
 use std::fmt;
 
+use oo7::dbus::ServiceError;
+
 #[derive(Debug)]
 pub enum Error {
     // File backend error
@@ -12,6 +14,8 @@ pub enum Error {
     EmptyPassword,
     // Invalid item error
     InvalidItem(oo7::portal::InvalidItemError),
+    // ServiceError
+    Service(ServiceError),
 }
 
 impl From<zbus::Error> for Error {
@@ -32,6 +36,12 @@ impl From<std::io::Error> for Error {
     }
 }
 
+impl From<ServiceError> for Error {
+    fn from(err: ServiceError) -> Self {
+        Self::Service(err)
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -40,6 +50,7 @@ impl fmt::Display for Error {
             Self::IO(err) => write!(f, "IO error {err}"),
             Self::EmptyPassword => write!(f, "Login password can't be empty"),
             Self::InvalidItem(err) => write!(f, "Item cannot be decrypted {err}"),
+            Self::Service(err) => write!(f, "Service error {err}"),
         }
     }
 }

server/src/item.rs

@@ -37,9 +37,9 @@ impl Item {
         &self,
         session: OwnedObjectPath,
     ) -> Result<(SecretInner,), ServiceError> {
-        let manager = self.manager.lock().await;
+        let service = self.manager.lock().await.service()?;
 
-        let Some(session) = manager.session(&session) else {
+        let Some(session) = service.session(&session).await else {
             tracing::error!("The session `{}` does not exist.", session);
             return Err(ServiceError::NoSession(format!(
                 "The session `{}` does not exist.",
@@ -83,9 +83,9 @@ impl Item {
 
     pub async fn set_secret(&self, secret: SecretInner) -> Result<(), ServiceError> {
         let SecretInner(session, iv, secret, _content_type) = secret;
-        let manager = self.manager.lock().await;
+        let service = self.manager.lock().await.service()?;
 
-        let Some(session) = manager.session(&session) else {
+        let Some(session) = service.session(&session).await else {
             tracing::error!("The session `{}` does not exist.", session);
             return Err(ServiceError::NoSession(format!(
                 "The session `{}` does not exist.",

server/src/service.rs

@@ -27,6 +27,8 @@ pub struct Service {
     // Properties
     collections: Arc<Mutex<Vec<Collection>>>,
     // Other attributes
+    // sessions mapped to their corresponding object path on the bus
+    sessions: Arc<Mutex<HashMap<OwnedObjectPath, Arc<Session>>>>,
     manager: Arc<Mutex<ServiceManager>>,
 }
 
@@ -56,10 +58,10 @@ impl Service {
 
         {
             let session = Arc::new(session.clone());
-            self.manager
+            self.sessions
                 .lock()
                 .await
-                .insert_session(path.clone(), Arc::clone(&session));
+                .insert(path.clone(), Arc::clone(&session));
         }
 
         object_server.at(&path, session).await?;
@@ -256,9 +258,19 @@ impl Service {
         let object_server = connection.object_server();
         let service = Self {
             collections: Default::default(),
+            sessions: Default::default(),
             manager: Arc::new(Mutex::new(ServiceManager::new(connection.clone()))),
         };
 
+        {
+            let service_clone = Arc::new(service.clone());
+            service
+                .manager
+                .lock()
+                .await
+                .set_service(Arc::clone(&service_clone));
+        }
+
         object_server
             .at(
                 oo7::dbus::api::Service::PATH.as_deref().unwrap(),
@@ -350,4 +362,12 @@ impl Service {
 
         Ok((without_prompt, with_prompt))
     }
+
+    pub async fn session(&self, path: &OwnedObjectPath) -> Option<Arc<Session>> {
+        self.sessions.lock().await.get(path).map(Arc::clone)
+    }
+
+    pub async fn remove_session(&self, path: &OwnedObjectPath) {
+        self.sessions.lock().await.remove(path);
+    }
 }

server/src/service_manager.rs

@@ -1,24 +1,24 @@
 // Secret Service Manager
 
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
+use oo7::dbus::ServiceError;
 use tokio::sync::RwLock;
-use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+use zbus::zvariant::ObjectPath;
 
-use crate::session::Session;
+use crate::Service;
 
 #[derive(Debug)]
 pub struct ServiceManager {
     connection: zbus::Connection,
-    // sessions mapped to their corresponding object path on the bus
-    sessions: HashMap<OwnedObjectPath, Arc<Session>>,
+    service: Option<Arc<Service>>,
     session_index: Arc<RwLock<u32>>,
 }
 
 impl ServiceManager {
     pub fn new(connection: zbus::Connection) -> Self {
         Self {
-            sessions: Default::default(),
+            service: Default::default(),
             session_index: Default::default(),
             connection,
         }
@@ -28,22 +28,24 @@ impl ServiceManager {
         self.connection.object_server()
     }
 
-    pub fn session(&self, path: &OwnedObjectPath) -> Option<Arc<Session>> {
-        self.sessions.get(path).map(Arc::clone)
-    }
-
-    pub fn insert_session(&mut self, path: OwnedObjectPath, session: Arc<Session>) {
-        self.sessions.insert(path, session);
+    pub fn service(&self) -> Result<Arc<Service>, ServiceError> {
+        if let Some(service) = &self.service {
+            Ok(Arc::clone(service))
+        } else {
+            Err(ServiceError::ZBus(zbus::Error::FDO(Box::new(
+                zbus::fdo::Error::Failed("Service isn't initialized yet.".to_string()),
+            ))))
+        }
     }
 
-    pub fn remove_session(&mut self, path: &OwnedObjectPath) {
-        self.sessions.remove(path);
+    pub fn set_service(&mut self, service: Arc<Service>) {
+        self.service = Some(service);
     }
 
     pub fn signal_emitter<'a, P>(
         &self,
         path: P,
-    ) -> Result<zbus::object_server::SignalEmitter<'a>, oo7::dbus::ServiceError>
+    ) -> Result<zbus::object_server::SignalEmitter<'a>, ServiceError>
     where
         P: TryInto<ObjectPath<'a>>,
         P::Error: Into<zbus::Error>,

server/src/session.rs

@@ -21,7 +21,9 @@ impl Session {
         &self,
         #[zbus(object_server)] object_server: &zbus::ObjectServer,
     ) -> Result<(), ServiceError> {
-        self.manager.lock().await.remove_session(&self.path);
+        let service = self.manager.lock().await.service()?;
+
+        service.remove_session(&self.path).await;
         object_server.remove::<Self, _>(&self.path).await?;
 
         Ok(())