Orchestrate communication between RbxSession and VfsSession

server/src/file_route.rs

@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf, Component};
 
 use partition::Partition;
 
-#[derive(Debug, Clone, PartialEq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FileRoute {
     pub partition: String,
     pub route: Vec<String>,

server/src/rbx_session.rs

@@ -1,43 +1,93 @@
 use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
-use id::Id;
+use file_route::FileRoute;
+use id::{Id, get_id};
 use partition::Partition;
 use rbx::RbxInstance;
 use session::SessionConfig;
+use vfs_session::{VfsSession, FileItem};
+
+fn file_to_instances(file_item: &FileItem, partition: &Partition, output: &mut HashMap<Id, RbxInstance>) -> Id {
+    match file_item {
+        FileItem::File { contents, route } => {
+            let mut properties = HashMap::new();
+            properties.insert("Value".to_string(), contents.clone());
+
+            let primary_id = get_id();
+
+            output.insert(primary_id, RbxInstance {
+                name: route.name(partition).to_string(),
+                class_name: "StringValue".to_string(),
+                parent: None,
+                properties,
+            });
+
+            primary_id
+        },
+        FileItem::Directory { children, route } => {
+            let primary_id = get_id();
+
+            output.insert(primary_id, RbxInstance {
+                name: route.name(partition).to_string(),
+                class_name: "Folder".to_string(),
+                parent: None,
+                properties: HashMap::new(),
+            });
+
+            for child_file_item in children.values() {
+                let mut child_instances = HashMap::new();
+                let child_id = file_to_instances(child_file_item, partition, &mut child_instances);
+
+                child_instances.get_mut(&child_id).unwrap().parent = Some(primary_id);
+
+                for (instance_id, instance) in child_instances.drain() {
+                    output.insert(instance_id, instance);
+                }
+            }
+
+            primary_id
+        }
+    }
+}
 
 pub struct RbxSession {
-    pub config: SessionConfig,
+    config: SessionConfig,
+
+    vfs_session: Arc<RwLock<VfsSession>>,
 
     /// The RbxInstance that represents each partition.
-    pub partition_instances: HashMap<String, Id>,
+    partition_instances: HashMap<String, Id>,
 
     /// The store of all instances in the session.
-    pub instances: HashMap<Id, RbxInstance>,
+    instances: HashMap<Id, RbxInstance>,
 
-    // pub instances_by_route: HashMap<FileRoute, Id>,
+    // instances_by_route: HashMap<FileRoute, Id>,
 }
 
 impl RbxSession {
-    pub fn new(config: SessionConfig) -> RbxSession {
+    pub fn new(config: SessionConfig, vfs_session: Arc<RwLock<VfsSession>>) -> RbxSession {
         RbxSession {
             config,
+            vfs_session,
             partition_instances: HashMap::new(),
             instances: HashMap::new(),
+            // instances_by_route: HashMap::new(),
         }
     }
 
-    // fn load_instances(&mut self) {
+    pub fn read_partitions(&mut self) {
-    //     for (partition_name, file_item) in &self.partition_files {
+        let vfs_session = self.vfs_session.read().unwrap();
-    //         let partition = self.partitions.get(partition_name).unwrap();
-    //         let (root_id, mut instances) = file_to_instance(&file_item, partition);
 
-    //         // there has to be an std method for this
+        for partition in self.config.partitions.values() {
-    //         // oh well
+            let route = FileRoute {
-    //         for (instance_id, instance) in instances.drain() {
+                partition: partition.name.clone(),
-    //             self.instances.insert(instance_id, instance);
+                route: Vec::new(),
-    //         }
+            };
+            let file_item = vfs_session.get_file_item(&route).unwrap();
+            let root_id = file_to_instances(file_item, partition, &mut self.instances);
 
-    //         self.partition_instances.insert(partition_name.clone(), root_id);
+            self.partition_instances.insert(partition.name.clone(), root_id);
-    //     }
+        }
-    // }
+    }
 }

server/src/session.rs

@@ -2,11 +2,9 @@ use std::collections::HashMap;
 use std::sync::{mpsc, Arc, RwLock};
 use std::thread;
 
-use id::{Id, get_id};
 use partition::Partition;
-use rbx::RbxInstance;
 use rbx_session::RbxSession;
-use vfs_session::{VfsSession, FileItem};
+use vfs_session::VfsSession;
 use partition_watcher::PartitionWatcher;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -18,49 +16,6 @@ pub struct SessionConfig {
 trait Middleware {
 }
 
-fn file_to_instances(file_item: &FileItem, partition: &Partition, output: &mut HashMap<Id, RbxInstance>) -> Id {
-    match file_item {
-        &FileItem::File { ref contents, ref route } => {
-            let mut properties = HashMap::new();
-            properties.insert("Value".to_string(), contents.clone());
-
-            let primary_id = get_id();
-
-            output.insert(primary_id, RbxInstance {
-                name: route.name(partition).to_string(),
-                class_name: "StringValue".to_string(),
-                parent: None,
-                properties,
-            });
-
-            primary_id
-        },
-        &FileItem::Directory { ref children, ref route } => {
-            let primary_id = get_id();
-
-            output.insert(primary_id, RbxInstance {
-                name: route.name(partition).to_string(),
-                class_name: "Folder".to_string(),
-                parent: None,
-                properties: HashMap::new(),
-            });
-
-            for child_file_item in children.values() {
-                let mut child_instances = HashMap::new();
-                let child_id = file_to_instances(child_file_item, partition, &mut child_instances);
-
-                child_instances.get_mut(&child_id).unwrap().parent = Some(primary_id);
-
-                for (instance_id, instance) in child_instances.drain() {
-                    output.insert(instance_id, instance);
-                }
-            }
-
-            primary_id
-        }
-    }
-}
-
 pub struct Session {
     config: SessionConfig,
     vfs_session: Arc<RwLock<VfsSession>>,
@@ -71,9 +26,12 @@ pub struct Session {
 
 impl Session {
     pub fn new(config: SessionConfig) -> Session {
+        let vfs_session = Arc::new(RwLock::new(VfsSession::new(config.clone())));
+        let rbx_session = Arc::new(RwLock::new(RbxSession::new(config.clone(), vfs_session.clone())));
+
         Session {
-            vfs_session: Arc::new(RwLock::new(VfsSession::new(config.clone()))),
+            vfs_session,
-            rbx_session: Arc::new(RwLock::new(RbxSession::new(config.clone()))),
+            rbx_session,
             middlewares: Vec::new(),
             watchers: Vec::new(),
             config,
@@ -81,6 +39,16 @@ impl Session {
     }
 
     pub fn start(&mut self) {
+        {
+            let mut vfs_session = self.vfs_session.write().unwrap();
+            vfs_session.read_partitions();
+        }
+
+        {
+            let mut rbx_session = self.rbx_session.write().unwrap();
+            rbx_session.read_partitions();
+        }
+
         let (tx, rx) = mpsc::channel();
 
         for partition in self.config.partitions.values() {

server/src/vfs_session.rs

@@ -58,6 +58,22 @@ impl VfsSession {
         println!("Got change {:?}", change);
     }
 
+    pub fn get_file_item(&self, route: &FileRoute) -> Option<&FileItem> {
+        let partition = self.partition_files.get(&route.partition)?;
+        let mut current = partition;
+
+        for piece in &route.route {
+            match current {
+                FileItem::File { .. } => return None,
+                FileItem::Directory { children, .. } => {
+                    current = children.get(piece)?;
+                },
+            }
+        }
+
+        Some(current)
+    }
+
     fn read(&self, route: &FileRoute) -> Result<FileItem, ()> {
         let partition_path = &self.config.partitions.get(&route.partition)
             .ok_or(())?.path;