refactor: move settings inside connection

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,3 +1,4 @@
+#[derive(Clone)]
 pub struct BoardSettings {
     pub arch: Option<String>,
     pub start_address: u64,

tockloader-lib/src/command_impl/erase_apps.rs

@@ -1,14 +1,13 @@
 use async_trait::async_trait;
 
-use crate::board_settings::BoardSettings;
-use crate::connection::TockloaderConnection;
+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, settings: &BoardSettings) -> Result<(), TockloaderError> {
-        self.write(settings.start_address, vec![0u8], settings)
+    async fn erase_apps(&mut self) -> Result<(), TockloaderError> {
+        self.write(self.get_settings().start_address, vec![0u8])
             .await
     }
 }

tockloader-lib/src/command_impl/generalized.rs

@@ -2,7 +2,6 @@ use async_trait::async_trait;
 
 use crate::attributes::app_attributes::AppAttributes;
 use crate::attributes::system_attributes::SystemAttributes;
-use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
 use crate::{IOCommands, IO};
@@ -16,28 +15,20 @@ impl IO for TockloaderConnection {
         }
     }
 
-    async fn write(
-        &mut self,
-        address: u64,
-        pkt: Vec<u8>,
-        settings: &BoardSettings,
-    ) -> Result<(), TockloaderError> {
+    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt, settings).await,
-            TockloaderConnection::Serial(conn) => conn.write(address, pkt, settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt).await,
+            TockloaderConnection::Serial(conn) => conn.write(address, pkt).await,
         }
     }
 }
 
 #[async_trait]
 impl IOCommands for TockloaderConnection {
-    async fn read_installed_apps(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+    async fn read_installed_apps(&mut self) -> Result<Vec<AppAttributes>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.read_installed_apps(settings).await,
-            TockloaderConnection::Serial(conn) => conn.read_installed_apps(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read_installed_apps().await,
+            TockloaderConnection::Serial(conn) => conn.read_installed_apps().await,
         }
     }
 

tockloader-lib/src/command_impl/info.rs

@@ -1,18 +1,14 @@
 use async_trait::async_trait;
 
 use crate::attributes::general_attributes::GeneralAttributes;
-use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
 use crate::{CommandInfo, IOCommands};
 
 #[async_trait]
 impl CommandInfo for TockloaderConnection {
-    async fn info(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<GeneralAttributes, TockloaderError> {
-        let installed_apps = self.read_installed_apps(settings).await.unwrap();
+    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

@@ -1,21 +1,17 @@
 use async_trait::async_trait;
 
 use crate::attributes::app_attributes::AppAttributes;
-use crate::board_settings::BoardSettings;
 use crate::command_impl::reshuffle_apps::{create_pkt, reshuffle_apps, TockApp};
-use crate::connection::TockloaderConnection;
+use crate::connection::{Connection, TockloaderConnection};
 use crate::errors::TockloaderError;
 use crate::tabs::tab::Tab;
 use crate::{CommandInstall, CommandList, IO};
 
 #[async_trait]
 impl CommandInstall for TockloaderConnection {
-    async fn install_app(
-        &mut self,
-        settings: &BoardSettings,
-        tab: Tab,
-    ) -> Result<(), TockloaderError> {
-        let app_attributes_list: Vec<AppAttributes> = self.list(settings).await.unwrap();
+    async fn install_app(&mut self, tab: Tab) -> Result<(), TockloaderError> {
+        let settings = self.get_settings();
+        let app_attributes_list: Vec<AppAttributes> = self.list().await.unwrap();
         let mut tock_app_list = app_attributes_list
             .iter()
             .map(TockApp::from_app_attributes)
@@ -24,7 +20,7 @@ impl CommandInstall for TockloaderConnection {
         // obtain the binaries in a vector
         let mut app_binaries: Vec<Vec<u8>> = Vec::new();
 
-        let mut address = settings.start_address;
+        let mut address = self.get_settings().start_address;
         for app in app_attributes_list.iter() {
             app_binaries.push(
                 self.read(address, app.tbf_header.total_size() as usize)
@@ -34,20 +30,23 @@ impl CommandInstall for TockloaderConnection {
             address += app.tbf_header.total_size() as u64;
         }
 
-        let mut app = TockApp::from_tab(&tab, settings).unwrap();
+        let mut app = TockApp::from_tab(&tab, &settings).unwrap();
 
         app.replace_idx(tock_app_list.len());
         tock_app_list.push(app.clone());
 
-        app_binaries.push(tab.extract_binary(settings.arch.clone().unwrap()).unwrap());
+        app_binaries.push(
+            tab.extract_binary(self.get_settings().arch.clone().unwrap())
+                .unwrap(),
+        );
 
-        let configuration = reshuffle_apps(settings, tock_app_list).unwrap();
+        let configuration = reshuffle_apps(&settings, tock_app_list).unwrap();
 
         // create the pkt, this contains all the binaries in a vec
         let pkt = create_pkt(configuration, app_binaries);
 
         // write the pkt
-        let _ = self.write(settings.start_address, pkt, settings).await;
+        let _ = self.write(self.get_settings().start_address, pkt).await;
         Ok(())
     }
 }

tockloader-lib/src/command_impl/list.rs

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

tockloader-lib/src/command_impl/probers/io.rs

@@ -3,7 +3,6 @@ use probe_rs::{flashing::DownloadOptions, MemoryInterface};
 
 use crate::{
     attributes::{app_attributes::AppAttributes, system_attributes::SystemAttributes},
-    board_settings::BoardSettings,
     connection::{Connection, ProbeRSConnection},
     errors::{InternalError, TockloaderError},
     IOCommands, IO,
@@ -23,12 +22,7 @@ impl IO for ProbeRSConnection {
         Ok(appdata)
     }
 
-    async fn write(
-        &mut self,
-        address: u64,
-        pkt: Vec<u8>,
-        _settings: &BoardSettings,
-    ) -> Result<(), TockloaderError> {
+    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
         }
@@ -47,13 +41,11 @@ impl IO for ProbeRSConnection {
 
 #[async_trait]
 impl IOCommands for ProbeRSConnection {
-    async fn read_installed_apps(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+    async fn read_installed_apps(&mut self) -> Result<Vec<AppAttributes>, TockloaderError> {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
         }
+        let settings = self.get_settings();
         let session = self.session.as_mut().expect("Board must be open");
         let mut core = session.core(self.target_info.core)?;
 

tockloader-lib/src/command_impl/serial/io.rs

@@ -2,7 +2,6 @@ use async_trait::async_trait;
 
 use crate::{
     attributes::{app_attributes::AppAttributes, system_attributes::SystemAttributes},
-    board_settings::BoardSettings,
     bootloader_serial::{issue_command, ping_bootloader_and_wait_for_response, Command, Response},
     connection::{Connection, SerialConnection},
     errors::{InternalError, TockloaderError},
@@ -37,12 +36,8 @@ impl IO for SerialConnection {
         Ok(appdata)
     }
 
-    async fn write(
-        &mut self,
-        address: u64,
-        pkt: Vec<u8>,
-        settings: &BoardSettings,
-    ) -> Result<(), TockloaderError> {
+    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
+        let settings = self.get_settings();
         let stream = self.stream.as_mut().expect("Board must be open");
         let mut binary = pkt.clone();
 
@@ -77,13 +72,11 @@ impl IO for SerialConnection {
 
 #[async_trait]
 impl IOCommands for SerialConnection {
-    async fn read_installed_apps(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+    async fn read_installed_apps(&mut self) -> Result<Vec<AppAttributes>, TockloaderError> {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
         }
+        let settings = self.get_settings();
         let stream = self.stream.as_mut().expect("Board must be open");
 
         ping_bootloader_and_wait_for_response(stream).await?;