A lot of improvements + real usage on the plugin

mveril · mveril · commit 0b416fc482c3 · 2025-01-24T13:26:15.000+01:00
diff --git a/plugin/src/lib.rs b/plugin/src/lib.rs
@@ -6,7 +6,7 @@ use log_instrument::instrument;
 use plugin::{Result, WSLPluginV1};
 use std::{env, io::Read};
 use windows::{
-    core::{Error as WinError, Result as WinResult, GUID},
+    core::{Error as WinError, Result as WinResult},
     Win32::Foundation::E_FAIL,
 };
 use wslplugins_rs::wsl_user_configuration::bitflags::WSLUserConfigurationFlags;
@@ -58,12 +58,12 @@ impl WSLPluginV1 for Plugin {
     ) -> Result<()> {
         let flags: WSLUserConfigurationFlags = user_settings.custom_configuration_flags().into();
         info!("User configuration {:?}", flags);
-
-        let ver_args = ["/bin/cat", "/proc/version"];
         match self
             .context
             .api
-            .execute_binary(session, ver_args[0], &ver_args)
+            .new_command(session, "/bin/cat")
+            .arg("/proc/version")
+            .execute()
         {
             Ok(mut stream) => {
                 let mut buf = String::new();
@@ -81,7 +81,7 @@ impl WSLPluginV1 for Plugin {
                 )
             }
         };
-        self.log_os_release(session, None);
+        self.log_os_release(session, DistributionID::System);
         Ok(())
     }
 
@@ -101,7 +101,7 @@ impl WSLPluginV1 for Plugin {
             // Use unknow if init_pid not available
             distribution.init_pid().map(|res| res.to_string()).unwrap_or("Unknow".to_string())
         );
-        self.log_os_release(session, Some(distribution.id()));
+        self.log_os_release(session, DistributionID::User(distribution.id()));
         Ok(())
     }
 
@@ -132,21 +132,15 @@ impl WSLPluginV1 for Plugin {
 }
 
 impl Plugin {
-    fn log_os_release(&self, session: &WSLSessionInformation, distro_id: Option<GUID>) {
-        let args: [&str; 2] = ["/bin/cat", "/etc/os-release"];
-        let tcp_stream: std::result::Result<std::net::TcpStream, api::Error> = match distro_id {
-            Some(dist_id) => self
-                .context
-                .api
-                .execute_binary_in_distribution(session, dist_id, args[0], &args),
-            None => self
-                .context
-                .api
-                .execute_binary(session, args[0], &args)
-                .map_err(Into::into),
-        };
-        let result = tcp_stream;
-        match result {
+    fn log_os_release(&self, session: &WSLSessionInformation, distro_id: DistributionID) {
+        match self
+            .context
+            .api
+            .new_command(session, "/bin/cat")
+            .arg("/etc/os-release")
+            .distribution_id(distro_id)
+            .execute()
+        {
             Ok(stream) => match OsRelease::from_reader(stream) {
                 Ok(release) => {
                     if let Some(version) = release.version() {
diff --git a/wslplugins-rs/src/api/api_v1.rs b/wslplugins-rs/src/api/api_v1.rs
@@ -1,7 +1,7 @@
 extern crate wslplugins_sys;
 #[cfg(doc)]
 use super::Error;
-use super::Result;
+use super::{Result, WSLCommand};
 use crate::api::errors::require_update_error::Result as UpReqResult;
 use crate::utils::{cstring_from_str, encode_wide_null_terminated};
 use crate::wsl_session_information::WSLSessionInformation;
@@ -264,6 +264,30 @@ impl ApiV1 {
         };
         Ok(stream)
     }
+    /// Creates a new `WSLCommand` instance tied to the current WSL API.
+    ///
+    /// This method initializes a `WSLCommand` with the provided session and
+    /// program details. The program is specified as a path that can be converted
+    /// to a `Utf8UnixPath`.
+    ///
+    /// # Parameters
+    /// - `session`: The session information associated with the WSL instance.
+    /// - `program`: A reference to the path of the program to be executed,
+    ///   represented as an object implementing `AsRef<Utf8UnixPath>`.
+    ///
+    /// # Returns
+    /// A new instance of `WSLCommand` configured to execute the specified program
+    /// within the provided WSL session.
+    ///
+    /// # Type Parameters
+    /// - `T`: A type that implements `AsRef<Utf8UnixPath>`.
+    pub fn new_command<'a, T: AsRef<Utf8UnixPath> + ?Sized>(
+        &'a self,
+        session: &'a WSLSessionInformation<'a>,
+        program: &'a T,
+    ) -> WSLCommand<'a> {
+        WSLCommand::new(self, session, program)
+    }
 
     fn check_required_version(&self, version: &WSLVersion) -> UpReqResult<()> {
         check_required_version_result(self.version(), version)
diff --git a/wslplugins-rs/src/api/mod.rs b/wslplugins-rs/src/api/mod.rs
@@ -26,5 +26,5 @@ pub use errors::Result;
 ///
 /// These utilities simplify common tasks, such as version checking or string manipulation.
 pub mod utils;
-pub mod wsl_command;
+mod wsl_command;
 pub use wsl_command::WSLCommand;
diff --git a/wslplugins-rs/src/api/wsl_command.rs b/wslplugins-rs/src/api/wsl_command.rs
@@ -1,95 +1,8 @@
-//! # WSL Distribution and WSLCommand Management Module
-//!
-//! This module provides abstractions for identifying and manipulating WSL
-//! distributions and for running commands in those distributions. It builds on the WSL APIs and
-//! uses [GUID]s to uniquely identify distributions.
+use typed_path::Utf8UnixPath;
 
-use std::{convert::TryFrom, fmt::Display, net::TcpStream};
-use thiserror::Error;
-use windows::core::GUID;
-
-#[cfg(doc)]
-use super::super::api::Error as ApiError;
-use super::super::api::Result as ApiResult;
-use crate::{CoreDistributionInformation, WSLContext, WSLSessionInformation};
-
-/// Represents a distribution identifier in WSL.
-///
-/// This can either be the system-level distribution or a user-specific distribution
-/// identified by a GUID.
-#[derive(Debug, Clone, Copy)]
-pub enum DistributionID {
-    /// Represents the system-level distribution.
-    System,
-    /// Represents a user-specific distribution identified by a GUID.
-    User(GUID),
-}
-
-/// Error type for conversion failures between `DistributionID` and GUID.
-#[derive(Debug, Error)]
-#[error("Cannot convert System distribution to GUID.")]
-pub struct ConversionError;
-
-impl TryFrom<DistributionID> for GUID {
-    type Error = ConversionError;
-
-    /// Attempts to convert a `DistributionID` into a GUID.
-    ///
-    /// # Errors
-    /// Returns `ConversionError` if the `DistributionID` is `System`.
-    fn try_from(value: DistributionID) -> Result<Self, Self::Error> {
-        match value {
-            DistributionID::User(id) => Ok(id),
-            DistributionID::System => Err(ConversionError),
-        }
-    }
-}
-
-impl From<GUID> for DistributionID {
-    /// Converts a GUID into a `DistributionID`.
-    fn from(value: GUID) -> Self {
-        Self::User(value)
-    }
-}
-
-impl<T: CoreDistributionInformation> From<T> for DistributionID {
-    /// Converts a type implementing `CoreDistributionInformation` into a `DistributionID`.
-    fn from(value: T) -> Self {
-        (*value.id()).into()
-    }
-}
-
-impl From<Option<GUID>> for DistributionID {
-    /// Converts an `Option<GUID>` into a `DistributionID`, defaulting to `System` if `None`.
-    fn from(value: Option<GUID>) -> Self {
-        match value {
-            Some(id) => Self::User(id),
-            None => Self::System,
-        }
-    }
-}
-
-impl From<DistributionID> for Option<GUID> {
-    /// Converts a `DistributionID` into an `Option<GUID>`.
-    fn from(value: DistributionID) -> Self {
-        match value {
-            DistributionID::System => None,
-            DistributionID::User(id) => Some(id),
-        }
-    }
-}
-
-impl Display for DistributionID {
-    /// Formats the `DistributionID` for display.
-    ///
-    /// Displays "System" for the system-level distribution, or the GUID for a user-specific distribution.
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DistributionID::System => f.write_str("System"),
-            DistributionID::User(id) => std::fmt::Debug::fmt(id, f),
-        }
-    }
-}
+use super::super::api::{ApiV1, Result as ApiResult};
+use crate::{DistributionID, WSLSessionInformation};
+use std::net::TcpStream;
 
 /// Represents a command to be executed in WSL.
 ///
@@ -98,11 +11,11 @@ impl Display for DistributionID {
 #[derive(Clone)]
 pub struct WSLCommand<'a> {
     /// The WSL context associated with the command.
-    context: &'static WSLContext,
+    api: &'a ApiV1<'a>,
     /// Arguments for the command.
     args: Vec<&'a str>,
     /// Path to the program being executed.
-    path: &'a str,
+    path: &'a Utf8UnixPath,
     /// The distribution ID under which the command is executed.
     distribution_id: DistributionID,
     /// Session information for the current WSL session.
@@ -112,26 +25,38 @@ pub struct WSLCommand<'a> {
 impl<'a> WSLCommand<'a> {
     /// Creates a new `WSLCommand` instance.
     ///
+    /// This function initializes a `WSLCommand` with the necessary details to
+    /// execute a program in a WSL instance.
+    ///
     /// # Parameters
-    /// - `context`: The WSL context.
-    /// - `session`: The session information for the WSL instance.
-    /// - `program`: The path to the program to be executed.
-    pub fn new(
-        context: &'static WSLContext,
+    /// - `api`: A reference to the WSL API version 1.
+    /// - `session`: The session information associated with the WSL instance.
+    /// - `program`: A reference to the path of the program to be executed,
+    ///   represented as an object implementing `AsRef<Utf8UnixPath>`.
+    ///
+    /// # Returns
+    /// A new `WSLCommand` instance.
+    ///
+    /// # Type Parameters
+    /// - `T`: A type that implements `AsRef<Utf8UnixPath>`.
+    pub(crate) fn new<T: AsRef<Utf8UnixPath> + ?Sized>(
+        api: &'a ApiV1<'a>,
         session: &'a WSLSessionInformation<'a>,
-        program: &'a str,
+        program: &'a T,
     ) -> Self {
+        let my_program = program.as_ref();
+        let program_str = my_program.as_str();
         Self {
-            context,
-            args: vec![program],
-            path: program,
+            api,
+            args: vec![program_str],
+            path: &my_program,
             distribution_id: DistributionID::System,
             session,
         }
     }
 
     /// Returns the path of the command.
-    pub fn get_path(&self) -> &'a str {
+    pub fn get_path(&self) -> &'a Utf8UnixPath {
         self.path
     }
 
@@ -156,7 +81,7 @@ impl<'a> WSLCommand<'a> {
 
     /// Resets the first argument to the path of the command.
     pub fn reset_arg0(&mut self) -> &mut Self {
-        self.args[0] = self.path;
+        self.args[0] = self.path.as_str();
         self
     }
 
@@ -233,13 +158,12 @@ impl<'a> WSLCommand<'a> {
     pub fn execute(&mut self) -> ApiResult<TcpStream> {
         let stream = match self.distribution_id {
             DistributionID::System => {
-                self.context
-                    .api
+                self.api
                     .execute_binary(self.session, self.path, self.args.as_slice())?
             }
-            DistributionID::User(id) => self.context.api.execute_binary_in_distribution(
+            DistributionID::User(id) => self.api.execute_binary_in_distribution(
                 self.session,
-                &id,
+                id,
                 self.path,
                 self.args.as_slice(),
             )?,
diff --git a/wslplugins-rs/src/distribution_id.rs b/wslplugins-rs/src/distribution_id.rs
diff --git a/wslplugins-rs/src/lib.rs b/wslplugins-rs/src/lib.rs
