wip: refactored reshuffle

Author: addrian-77

tockloader-lib/src/attributes/app_attributes.rs

@@ -11,7 +11,6 @@ use tokio_serial::SerialStream;
 
 use crate::bootloader_serial::{issue_command, Command, Response};
 use crate::errors::{TockError, TockloaderError};
-use crate::IO;
 
 /// This structure contains all relevant information about a tock application.
 ///
@@ -299,9 +298,4 @@ impl AppAttributes {
         }
         Ok(apps_details)
     }
-
-    /// This function reads the full binary of a given app
-    pub async fn read_binary(&mut self, conn: &mut dyn IO) -> Result<Vec<u8>, TockloaderError> {
-        conn.read(self.address, self.size as usize).await
-    }
 }

tockloader-lib/src/board_settings.rs

@@ -1,6 +1,7 @@
 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 +11,7 @@ impl Default for BoardSettings {
         Self {
             arch: None,
             start_address: 0x30000,
+            page_size: 512,
         }
     }
 }

tockloader-lib/src/command_impl/erase_apps.rs

@@ -8,6 +8,7 @@ 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]).await
+        self.write(settings.start_address, vec![0u8], settings)
+            .await
     }
 }

tockloader-lib/src/command_impl/generalized.rs

@@ -16,10 +16,15 @@ impl IO for TockloaderConnection {
         }
     }
 
-    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
+    async fn write(
+        &mut self,
+        address: u64,
+        pkt: Vec<u8>,
+        settings: &BoardSettings,
+    ) -> Result<(), TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt).await,
-            TockloaderConnection::Serial(conn) => conn.write(address, pkt).await,
+            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt, settings).await,
+            TockloaderConnection::Serial(conn) => conn.write(address, pkt, settings).await,
         }
     }
 }

tockloader-lib/src/command_impl/install.rs

@@ -2,7 +2,7 @@ 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};
+use crate::command_impl::reshuffle_apps::{create_pkt, reshuffle_apps, TockApp};
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
 use crate::tabs::tab::Tab;
@@ -15,37 +15,36 @@ impl CommandInstall for TockloaderConnection {
         settings: &BoardSettings,
         tab: Tab,
     ) -> Result<(), TockloaderError> {
-        let mut installed_apps: Vec<AppAttributes> = self.list(settings).await.unwrap();
-
-        if let Some(mut app) = reconstruct_app(Some(&tab), settings) {
-            app.index = installed_apps.len() as u8;
-            installed_apps.push(app.clone());
-        }
+        let app_attributes_list: Vec<AppAttributes> = self.list(settings).await.unwrap();
+        let mut tock_app_list = app_attributes_list
+            .iter()
+            .map(|app| TockApp::from_app_attributes(app, settings))
+            .collect::<Vec<TockApp>>();
 
         // obtain the binaries in a vector
         let mut app_binaries: Vec<Vec<u8>> = Vec::new();
 
-        for app in installed_apps.iter() {
-            match app.installed {
-                true => {
-                    app_binaries.push(app.clone().read_binary(self).await.unwrap());
-                }
-                false => {
-                    // TODO(adi): change this when TBF Filtering will get merged
-                    app_binaries.push(
-                        tab.extract_binary(settings.arch.as_ref().unwrap().as_str())
-                            .unwrap(),
-                    );
-                }
-            }
+        for app in tock_app_list.iter() {
+            app_binaries.push(app.clone().read_binary(self).await.unwrap())
         }
-        let configuration = reshuffle_apps(settings, installed_apps).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.as_ref().unwrap().as_str())
+                .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).await;
+        let _ = self.write(settings.start_address, pkt, settings).await;
         Ok(())
     }
 }

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

@@ -23,7 +23,12 @@ impl IO for ProbeRSConnection {
         Ok(appdata)
     }
 
-    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
+    async fn write(
+        &mut self,
+        address: u64,
+        pkt: Vec<u8>,
+        _settings: &BoardSettings,
+    ) -> Result<(), TockloaderError> {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
         }