From 5acbc9f967cd1ce1f19fe28f7aebb499451bedfc Mon Sep 17 00:00:00 2001 From: Lucien Greathouse Date: Sat, 12 May 2018 15:27:20 -0700 Subject: [PATCH] Orchestrate communication between RbxSession and VfsSession --- server/src/file_route.rs | 2 +- server/src/rbx_session.rs | 86 +++++++++++++++++++++++++++++++-------- server/src/session.rs | 64 ++++++++--------------------- server/src/vfs_session.rs | 16 ++++++++ 4 files changed, 101 insertions(+), 67 deletions(-) diff --git a/server/src/file_route.rs b/server/src/file_route.rs index 8ebc2470..9eddc7ef 100644 --- a/server/src/file_route.rs +++ b/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, diff --git a/server/src/rbx_session.rs b/server/src/rbx_session.rs index df3dbfbb..230fc3fa 100644 --- a/server/src/rbx_session.rs +++ b/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 { + 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>, /// The RbxInstance that represents each partition. - pub partition_instances: HashMap, + partition_instances: HashMap, /// The store of all instances in the session. - pub instances: HashMap, + instances: HashMap, - // pub instances_by_route: HashMap, + // instances_by_route: HashMap, } impl RbxSession { - pub fn new(config: SessionConfig) -> RbxSession { + pub fn new(config: SessionConfig, vfs_session: Arc>) -> RbxSession { RbxSession { config, + vfs_session, partition_instances: HashMap::new(), instances: HashMap::new(), + // instances_by_route: HashMap::new(), } } - // fn load_instances(&mut self) { - // for (partition_name, file_item) in &self.partition_files { - // let partition = self.partitions.get(partition_name).unwrap(); - // let (root_id, mut instances) = file_to_instance(&file_item, partition); + pub fn read_partitions(&mut self) { + let vfs_session = self.vfs_session.read().unwrap(); - // // there has to be an std method for this - // // oh well - // for (instance_id, instance) in instances.drain() { - // self.instances.insert(instance_id, instance); - // } + for partition in self.config.partitions.values() { + let route = FileRoute { + partition: partition.name.clone(), + 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); + } + } } diff --git a/server/src/session.rs b/server/src/session.rs index 34f8a8e3..bc443c1e 100644 --- a/server/src/session.rs +++ b/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 { - 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>, @@ -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()))), - rbx_session: Arc::new(RwLock::new(RbxSession::new(config.clone()))), + vfs_session, + 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() { diff --git a/server/src/vfs_session.rs b/server/src/vfs_session.rs index fdda63ec..1bf11d55 100644 --- a/server/src/vfs_session.rs +++ b/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 { let partition_path = &self.config.partitions.get(&route.partition) .ok_or(())?.path;