hakowork/rojo
3
0
Fork 0
mirror of https://github.com/rojo-rbx/rojo.git synced 2026-10-23 14:01:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Orchestrate communication between RbxSession and VfsSession

Browse source
This commit is contained in:
Lucien Greathouse 2018-05-12 15:27:20 -07:00
parent cb548719b2
commit 5acbc9f967
4 changed files with 101 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

2
server/src/file_route.rs
View file

@ -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>,

86
server/src/rbx_session.rs
View file

@ -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) {
// 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);
}
}
}

64
server/src/session.rs
View file

@ -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()))),
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() {

16
server/src/vfs_session.rs
View file

@ -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;