implement minimal suite of server methods

Author: ethangreen-dev

src/cli.rs

@@ -257,4 +257,10 @@ pub enum Commands {
 
     /// Update the tcli ecosystem schema.
     UpdateSchema,
+
+    /// Start the tcli server.
+    Server {
+        #[clap(long, default_value = "./")]
+        project_path: PathBuf,
+    },
 }

src/error.rs

@@ -1,5 +1,6 @@
 use std::path::{Path, PathBuf};
 
+use crate::server::ServerError;
 use crate::ts::error::ApiError;
 
 use crate::game::error::GameError;
@@ -22,21 +23,18 @@ pub enum Error {
     Api(#[from] ApiError),
 
     #[error("{0}")]
-    Io(#[from] IoError),
-
-    #[error("{0}")]
-    JsonParse(#[from] serde_json::Error),
+    Server(#[from] ServerError),
 
     #[error("{0}")]
-    TomlDeserialize(#[from] toml::de::Error),
+    Io(#[from] IoError),
 
     #[error("{0}")]
-    TomlSerialize(#[from] toml::ser::Error),
+    Parse(#[from] ParseError),
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum IoError {
-    #[error("A file IO error occured: {0}.")]
+    #[error("A file IO error occurred: {0}.")]
     Native(std::io::Error, Option<PathBuf>),
 
     #[error("File not found: {0}.")]
@@ -64,6 +62,18 @@ pub enum IoError {
     ZipError(#[from] zip::result::ZipError),
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum ParseError {
+    #[error("A json parse error occurred: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("A toml serialization error occurred: {0}")]
+    TomlSe(#[from] toml::ser::Error),
+
+    #[error("A toml deserialization error occured: {0}")]
+    TomlDe(#[from] toml::de::Error),
+}
+
 impl From<std::io::Error> for Error {
     fn from(value: std::io::Error) -> Self {
         Self::Io(IoError::Native(value, None))
@@ -82,6 +92,23 @@ impl From<zip::result::ZipError> for Error {
     }
 }
 
+impl From<serde_json::Error> for Error {
+    fn from(value: serde_json::Error) -> Self {
+        Self::Parse(ParseError::Json(value))
+    }
+}
+impl From<toml::de::Error> for Error {
+    fn from(value: toml::de::Error) -> Self {
+        Self::Parse(ParseError::TomlDe(value))
+    }
+}
+
+impl From<toml::ser::Error> for Error {
+    fn from(value: toml::ser::Error) -> Self {
+        Self::Parse(ParseError::TomlSe(value))
+    }
+}
+
 pub trait IoResultToTcli<R> {
     fn map_fs_error(self, path: impl AsRef<Path>) -> Result<R, IoError>;
 }

src/main.rs

@@ -1,5 +1,6 @@
 #![allow(dead_code)]
 
+use std::io::{self, Stdin};
 use std::path::PathBuf;
 
 use clap::Parser;
@@ -31,7 +32,7 @@ mod error;
 mod game;
 mod package;
 mod project;
-// mod server;
+mod server;
 mod ts;
 mod ui;
 mod util;
@@ -338,6 +339,8 @@ async fn main() -> Result<(), Error> {
                 let graph = DependencyGraph::from_graph(lock.package_graph);
 
                 for package in graph.digest() {
+                    println!("{}", package);
+
                     let package = Package::from_any(package).await?;
                     let Some(meta) = package.get_metadata().await? else {
                         continue;
@@ -350,6 +353,13 @@ async fn main() -> Result<(), Error> {
                 Ok(())
             }
         },
+        Commands::Server { project_path }=> {
+            let read = io::stdin();
+            let write = io::stdout();
+            server::spawn(read, write, &project_path).await?;
+
+            Ok(())
+        },
     };
 
     test

src/package/cache.rs

@@ -21,3 +21,7 @@ pub async fn get_temp_zip_file(
 pub fn get_cache_location(package: &PackageReference) -> PathBuf {
     CACHE_LOCATION.join(package.to_string())
 }
+
+pub fn is_cached(package: &PackageReference) -> bool {
+    CACHE_LOCATION.join(package.to_string()).exists()
+}

src/package/mod.rs

@@ -1,4 +1,4 @@
-mod cache;
+pub mod cache;
 pub mod index;
 pub mod install;
 pub mod resolver;

src/project/lock.rs

@@ -8,7 +8,7 @@ use md5::Md5;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::error::Error;
-use crate::package::Package;
+use crate::package::{Package, PackageMetadata};
 use crate::package::resolver::{DependencyGraph, InnerDepGraph};
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -76,6 +76,20 @@ impl LockFile {
 
         Ok(())
     }
+
+    pub async fn installed_packages(self) -> Result<Vec<PackageMetadata>, Error> {
+        let graph = DependencyGraph::from_graph(self.package_graph);
+        let mut packages = Vec::new();
+
+        for package in graph.digest() {
+            let package = Package::from_any(package).await?;
+            if let Some(meta) = package.get_metadata().await? {
+                packages.push(meta);
+            }
+        }
+
+        Ok(packages)
+    }
 }
 
 pub fn serialize<S: Serializer>(

src/server/lock.rs

@@ -3,7 +3,7 @@ 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";
+const LOCKFILE: &str = ".server-lock";
 
 pub struct ProjectLock {
     file: File,
@@ -27,7 +27,7 @@ impl ProjectLock {
 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();
+        fs::remove_file(&self.path).expect("Failed to remove lockfile.");
     }
 }
 

src/server/method/mod.rs

@@ -1,12 +1,22 @@
 pub mod package;
 pub mod project;
 
+use std::sync::RwLock;
+
+use futures::channel::mpsc::Sender;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
+use crate::project::Project;
+
 use self::package::PackageMethod;
 use self::project::ProjectMethod;
-use super::Error;
+use super::proto::Response;
+use super::{Error, ServerError};
+
+pub trait Routeable {
+    async fn route(&self, ctx: RwLock<Project>, send: Sender<Result<Response, Error>>);
+}
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub enum Method {
@@ -22,18 +32,18 @@ impl Method {
         let (namespace, name) = (
             split
                 .next()
-                .ok_or_else(|| Error::InvalidMethod(method.into()))?,
+                .ok_or_else(|| ServerError::InvalidMethod(method.into()))?,
             split
                 .next()
-                .ok_or_else(|| Error::InvalidMethod(method.into()))?,
+                .ok_or_else(|| ServerError::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()))?,
+            x => Err(ServerError::InvalidMethod(x.into()))?,
         })
     }
 }

src/server/method/package.rs

@@ -1,21 +1,61 @@
 use serde::{Deserialize, Serialize};
 
+use crate::package::{cache, Package};
+use crate::server::proto::{Id, Response};
+use crate::ts::package_reference::PackageReference;
+use crate::TCLI_HOME;
+use crate::server::{Runtime, ServerError};
+use crate::package::index::PackageIndex;
+
 use super::Error;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub enum PackageMethod {
     /// Get metadata about this package.
-    GetMetadata,
+    GetMetadata(GetMetadata),
     /// Determine if the package exists within the cache.
-    IsCached,
+    IsCached(IsCached),
+    /// Syncronize the package index.
+    SyncIndex,
 }
 
 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()))?,
+            "get_metadata" => Self::GetMetadata(super::parse_value(value)?),
+            "is_cached" => Self::IsCached(super::parse_value(value)?),
+            "sync_index" => Self::SyncIndex,
+            x => Err(ServerError::InvalidMethod(x.into()))?,
         })
     }
+
+    pub async fn route(&self, rt: &mut Runtime) -> Result<(), Error> {
+        match self {
+            Self::GetMetadata(data) => {
+                let index = PackageIndex::open(&TCLI_HOME).await?;
+                let package = index.get_package(&data.package).unwrap();
+                rt.send(Response::data_ok(Id::String("diowadaw".into()), package));
+            },
+            Self::IsCached(data) => {
+                let is_cached = cache::is_cached(&data.package);
+                rt.send(Response::data_ok(Id::String("dwdawdwa".into()), is_cached));
+            }
+            Self::SyncIndex => {
+                PackageIndex::sync(&TCLI_HOME).await?;
+                rt.send(Response::ok(Id::String("dwada".into())));
+            },
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub struct IsCached {
+    package: PackageReference,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub struct GetMetadata {
+    package: PackageReference,
 }