feat:io rework

Signed-off-by: addrian-77 <lunguadrian30@gmail.com>

Author: addrian-77

tockloader-cli/src/main.rs

@@ -111,8 +111,12 @@ async fn open_connection(user_options: &ArgMatches) -> Result<TockloaderConnecti
                 .context("No device is connected.")?
         };
 
-        let mut conn: TockloaderConnection =
-            SerialConnection::new(path, get_serial_target_info(user_options)).into();
+        let mut conn: TockloaderConnection = SerialConnection::new(
+            path,
+            get_serial_target_info(user_options),
+            get_board_settings(user_options),
+        )
+        .into();
         conn.open()
             .await
             .context("Failed to open serial connection.")?;
@@ -124,8 +128,12 @@ async fn open_connection(user_options: &ArgMatches) -> Result<TockloaderConnecti
                 .prompt()
                 .context("No debug probe is connected.")?;
 
-        let mut conn: TockloaderConnection =
-            ProbeRSConnection::new(ans, get_probe_target_info(user_options)).into();
+        let mut conn: TockloaderConnection = ProbeRSConnection::new(
+            ans,
+            get_probe_target_info(user_options),
+            get_board_settings(user_options),
+        )
+        .into();
 
         conn.open()
             .await
@@ -199,19 +207,17 @@ async fn main() -> Result<()> {
             cli::validate(&mut cmd, sub_matches);
 
             let mut conn = open_connection(sub_matches).await?;
-            let settings = get_board_settings(sub_matches);
 
-            let app_details = conn.list(&settings).await.context("Failed to list apps.")?;
+            let app_details = conn.list().await.context("Failed to list apps.")?;
 
             display::print_list(&app_details).await;
         }
         Some(("info", sub_matches)) => {
             cli::validate(&mut cmd, sub_matches);
             let mut conn = open_connection(sub_matches).await?;
-            let settings = get_board_settings(sub_matches);
 
             let mut attributes = conn
-                .info(&settings)
+                .info()
                 .await
                 .context("Failed to get data from the board.")?;
 
@@ -223,20 +229,16 @@ async fn main() -> Result<()> {
                 .context("Failed to use provided tab file.")?;
 
             let mut conn = open_connection(sub_matches).await?;
-            let settings = get_board_settings(sub_matches);
 
-            conn.install_app(&settings, tab_file)
+            conn.install_app(tab_file)
                 .await
                 .context("Failed to install app.")?;
         }
         Some(("erase-apps", sub_matches)) => {
             cli::validate(&mut cmd, sub_matches);
             let mut conn = open_connection(sub_matches).await?;
-            let settings = get_board_settings(sub_matches);
 
-            conn.erase_apps(&settings)
-                .await
-                .context("Failed to erase apps.")?;
+            conn.erase_apps().await.context("Failed to erase apps.")?;
         }
         _ => {
             println!("Could not run the provided subcommand.");

tockloader-lib/src/board_settings.rs

@@ -1,6 +1,8 @@
+#[derive(Clone)]
 pub struct BoardSettings {
     pub arch: Option<String>,
     pub start_address: u64,
+    pub page_size: u64,
 }
 
 // TODO(george-cosma): Does a default implementation make sense for this? Is a
@@ -10,6 +12,7 @@ impl Default for BoardSettings {
         Self {
             arch: None,
             start_address: 0x30000,
+            page_size: 512,
         }
     }
 }

tockloader-lib/src/command_impl/erase_apps.rs

@@ -0,0 +1,13 @@
+use async_trait::async_trait;
+
+use crate::connection::{Connection, TockloaderConnection};
+use crate::errors::TockloaderError;
+use crate::{CommandEraseApps, IO};
+
+#[async_trait]
+impl CommandEraseApps for TockloaderConnection {
+    async fn erase_apps(&mut self) -> Result<(), TockloaderError> {
+        self.write(self.get_settings().start_address, &[0u8])
+            .await
+    }
+}

tockloader-lib/src/command_impl/generalized.rs

@@ -1,59 +1,41 @@
 use async_trait::async_trait;
 
 use crate::attributes::app_attributes::AppAttributes;
-use crate::attributes::general_attributes::GeneralAttributes;
-use crate::board_settings::BoardSettings;
+use crate::attributes::system_attributes::SystemAttributes;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
-use crate::tabs::tab::Tab;
-use crate::{CommandEraseApps, CommandInfo, CommandInstall, CommandList};
+use crate::{IOCommands, IO};
 
 #[async_trait]
-impl CommandList for TockloaderConnection {
-    async fn list(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+impl IO for TockloaderConnection {
+    async fn read(&mut self, address: u64, size: usize) -> Result<Vec<u8>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.list(settings).await,
-            TockloaderConnection::Serial(conn) => conn.list(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read(address, size).await,
+            TockloaderConnection::Serial(conn) => conn.read(address, size).await,
         }
     }
-}
 
-#[async_trait]
-impl CommandInfo for TockloaderConnection {
-    async fn info(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<GeneralAttributes, TockloaderError> {
+    async fn write(&mut self, address: u64, pkt: &[u8]) -> Result<(), TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.info(settings).await,
-            TockloaderConnection::Serial(conn) => conn.info(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt).await,
+            TockloaderConnection::Serial(conn) => conn.write(address, pkt).await,
         }
     }
 }
 
 #[async_trait]
-impl CommandInstall for TockloaderConnection {
-    async fn install_app(
-        &mut self,
-        settings: &BoardSettings,
-        tab_file: Tab,
-    ) -> Result<(), TockloaderError> {
+impl IOCommands for TockloaderConnection {
+    async fn read_installed_apps(&mut self) -> Result<Vec<AppAttributes>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.install_app(settings, tab_file).await,
-            TockloaderConnection::Serial(conn) => conn.install_app(settings, tab_file).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read_installed_apps().await,
+            TockloaderConnection::Serial(conn) => conn.read_installed_apps().await,
         }
     }
-}
 
-#[async_trait]
-impl CommandEraseApps for TockloaderConnection {
-    async fn erase_apps(&mut self, settings: &BoardSettings) -> Result<(), TockloaderError> {
+    async fn read_system_attributes(&mut self) -> Result<SystemAttributes, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.erase_apps(settings).await,
-            TockloaderConnection::Serial(conn) => conn.erase_apps(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read_system_attributes().await,
+            TockloaderConnection::Serial(conn) => conn.read_system_attributes().await,
         }
     }
 }

tockloader-lib/src/command_impl/info.rs

@@ -0,0 +1,15 @@
+use async_trait::async_trait;
+
+use crate::attributes::general_attributes::GeneralAttributes;
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::{CommandInfo, IOCommands};
+
+#[async_trait]
+impl CommandInfo for TockloaderConnection {
+    async fn info(&mut self) -> Result<GeneralAttributes, TockloaderError> {
+        let installed_apps = self.read_installed_apps().await.unwrap();
+        let system_atributes = self.read_system_attributes().await.unwrap();
+        Ok(GeneralAttributes::new(system_atributes, installed_apps))
+    }
+}

tockloader-lib/src/command_impl/install.rs

@@ -0,0 +1,15 @@
+use async_trait::async_trait;
+
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::tabs::tab::Tab;
+use crate::CommandInstall;
+
+#[async_trait]
+impl CommandInstall for TockloaderConnection {
+    async fn install_app(
+        &mut self, _tab: Tab
+    ) -> Result<(), TockloaderError> {
+        todo!()
+    }
+}

tockloader-lib/src/command_impl/list.rs

@@ -0,0 +1,13 @@
+use async_trait::async_trait;
+
+use crate::attributes::app_attributes::AppAttributes;
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::{CommandList, IOCommands};
+
+#[async_trait]
+impl CommandList for TockloaderConnection {
+    async fn list(&mut self) -> Result<Vec<AppAttributes>, TockloaderError> {
+        self.read_installed_apps().await
+    }
+}

tockloader-lib/src/command_impl/mod.rs

@@ -1,3 +1,7 @@
+pub mod erase_apps;
 pub mod generalized;
+pub mod info;
+pub mod install;
+pub mod list;
 pub mod probers;
 pub mod serial;