[TS-2073] Server implementation for tooling interop

Cargo.toml

@@ -19,7 +19,11 @@ indicatif = { version = "0.17.8", features = ["improved_unicode", "tokio"] }
 # async runtime and helpers
 futures = "0.3"
 futures-util = "0.3"
-tokio = { version = "1.34", features = ["macros", "process", "rt-multi-thread"]}
+tokio = { version = "1.34", features = [
+    "macros",
+    "process",
+    "rt-multi-thread",
+] }
 tokio-util = { version = "0.7", features = ["io"] }
 async-compression = { version = "0.4", features = ["futures-io", "gzip"] }
 
@@ -45,3 +49,6 @@ log = "0.4.21"
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.50"
+
+[dev-dependencies]
+tempfile = "3.10"

src/main.rs

@@ -29,6 +29,7 @@ mod error;
 mod game;
 mod package;
 mod project;
+mod server;
 mod ts;
 mod ui;
 mod util;

src/server/lock.rs

@@ -0,0 +1,61 @@
+use std::fs::{self, File};
+use std::path::{Path, PathBuf};
+
+/// Only one server process can "own" a project at a single time.
+/// We enforce this exclusive access through the creation and deletion of this lockfile.
+const LOCKFILE: &'static str = ".server-lock";
+
+pub struct ProjectLock {
+    file: File,
+    path: PathBuf,
+}
+
+impl ProjectLock {
+    /// Attempt to acquire a lock on the provided directory.
+    pub fn lock(project_path: &Path) -> Option<Self> {
+        let lock = project_path.join(LOCKFILE);
+        match lock.is_file() {
+            true => None,
+            false => {
+                let file = File::create(&lock).ok()?;
+                Some(Self { file, path: lock })
+            }
+        }
+    }
+}
+
+impl Drop for ProjectLock {
+    fn drop(&mut self) {
+        // The file handle is dropped before this, so we can safely delete it.
+        fs::remove_file(&self.path).unwrap();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use tempfile::TempDir;
+
+    /// Test that project locks behave in the following way:
+    /// - Attempting to lock an already locked project MUST return None.
+    /// - Attempting to lock a project that is not locked will return a ProjectLock.
+    /// - Dropping a ProjectLock will remove the lockfile from the project.
+    #[test]
+    fn test_project_lock() {
+        let temp = TempDir::new().unwrap();
+        let root = temp.path();
+
+        // Acquire a lock on the directory.
+        {
+            let _lock =
+                ProjectLock::lock(root).expect("Failed to acquire lock on empty directory.");
+
+            // Attempting to acquire it again will return None.
+            let relock = ProjectLock::lock(root);
+            assert!(relock.is_none());
+        }
+
+        // Now that the previous lock is dropped we *should* be able to re-acquire it.
+        let _lock = ProjectLock::lock(root).expect("Failed to acquire lock on empty directory.");
+    }
+}

src/server/method/mod.rs

@@ -0,0 +1,43 @@
+pub mod package;
+pub mod project;
+
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
+use self::package::PackageMethod;
+use self::project::ProjectMethod;
+use super::Error;
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub enum Method {
+    Exit,
+    Project(ProjectMethod),
+    Package(PackageMethod),
+}
+
+/// Method namespace registration.
+impl Method {
+    pub fn from_value(method: &str, value: serde_json::Value) -> Result<Self, Error> {
+        let mut split = method.split('/');
+        let (namespace, name) = (
+            split
+                .next()
+                .ok_or_else(|| Error::InvalidMethod(method.into()))?,
+            split
+                .next()
+                .ok_or_else(|| Error::InvalidMethod(method.into()))?,
+        );
+
+        // Route namespaces to the appropriate enum variants for construction.
+        Ok(match namespace {
+            "exit" => Self::Exit,
+            "project" => Self::Project(ProjectMethod::from_value(name, value)?),
+            "package" => Self::Package(PackageMethod::from_value(name, value)?),
+            x => Err(Error::InvalidMethod(x.into()))?,
+        })
+    }
+}
+
+pub fn parse_value<T: DeserializeOwned>(value: serde_json::Value) -> Result<T, serde_json::Error> {
+    serde_json::from_value(value)
+}

src/server/method/package.rs

@@ -0,0 +1,21 @@
+use serde::{Deserialize, Serialize};
+
+use super::Error;
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub enum PackageMethod {
+    /// Get metadata about this package.
+    GetMetadata,
+    /// Determine if the package exists within the cache.
+    IsCached,
+}
+
+impl PackageMethod {
+    pub fn from_value(method: &str, value: serde_json::Value) -> Result<Self, Error> {
+        Ok(match method {
+            "get_metadata" => Self::GetMetadata,
+            "is_cached" => Self::IsCached,
+            x => Err(Error::InvalidMethod(x.into()))?,
+        })
+    }
+}