Extract common code from the flash subcommand action

Author: jessebraham

cargo-espflash/src/main.rs

@@ -11,11 +11,11 @@ use espflash::{
     cli::{
         board_info,
         clap::{ConnectOpts, FlashOpts},
-        connect,
+        connect, flash_elf_image,
         monitor::monitor,
         save_elf_as_image,
     },
-    Chip, Config, ImageFormatId, PartitionTable,
+    Chip, Config, ImageFormatId,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
 
@@ -122,79 +122,55 @@ fn flash(
     metadata: CargoEspFlashMeta,
     cargo_config: CargoConfig,
 ) -> Result<()> {
-    // Connect the Flasher to the target device and build the project, and store a
-    // reference to the artifact path.
     let mut flasher = connect(&opts.connect_opts, &config)?;
 
-    let path = build(&opts.build_opts, &cargo_config, Some(flasher.chip()))
+    let artifact_path = build(&opts.build_opts, &cargo_config, Some(flasher.chip()))
         .wrap_err("Failed to build project")?;
 
-    // If the '--bootloader' option is provided, load the binary file at the
-    // specified path.
-    let bootloader = if let Some(path) = opts
-        .flash_opts
-        .bootloader
-        .as_deref()
-        .or_else(|| metadata.bootloader.as_deref())
-    {
-        let path = fs::canonicalize(path).into_diagnostic()?;
-        let data = fs::read(path).into_diagnostic()?;
-        Some(data)
-    } else {
-        None
-    };
-
-    // If the '--partition-table' option is provided, load the partition table from
-    // the CSV at the specified path.
-    let partition_table = if let Some(path) = opts
-        .flash_opts
-        .partition_table
-        .as_deref()
-        .or_else(|| metadata.partition_table.as_deref())
-    {
-        let path = fs::canonicalize(path).into_diagnostic()?;
-        let data = fs::read_to_string(path)
-            .into_diagnostic()
-            .wrap_err("Failed to open partition table")?;
-        let table =
-            PartitionTable::try_from_str(data).wrap_err("Failed to parse partition table")?;
-        Some(table)
-    } else {
-        None
-    };
-
-    let image_format = opts
-        .build_opts
-        .format
-        .as_deref()
-        .map(ImageFormatId::from_str)
-        .transpose()?
-        .or(metadata.format);
-
     // Print the board information once the project has successfully built. We do
     // here rather than upon connection to show the Cargo output prior to the board
     // information, rather than breaking up cargo-espflash's output.
     flasher.board_info()?;
 
     // Read the ELF data from the build path and load it to the target.
-    let elf_data = fs::read(path).into_diagnostic()?;
+    let elf_data = fs::read(artifact_path).into_diagnostic()?;
+
     if opts.flash_opts.ram {
         flasher.load_elf_to_ram(&elf_data)?;
     } else {
-        flasher.load_elf_to_flash_with_format(
+        let bootloader = opts
+            .flash_opts
+            .bootloader
+            .as_deref()
+            .or(metadata.bootloader.as_deref());
+
+        let partition_table = opts
+            .flash_opts
+            .partition_table
+            .as_deref()
+            .or(metadata.partition_table.as_deref());
+
+        let image_format = opts
+            .build_opts
+            .format
+            .as_deref()
+            .map(ImageFormatId::from_str)
+            .transpose()?
+            .or(metadata.format);
+
+        flash_elf_image(
+            &mut flasher,
             &elf_data,
             bootloader,
             partition_table,
             image_format,
         )?;
     }
-    println!("\nFlashing has completed!");
 
     if opts.flash_opts.monitor {
         monitor(flasher.into_serial()).into_diagnostic()?;
     }
 
-    // We're all done!
     Ok(())
 }
 

espflash/src/cli/clap.rs

@@ -25,10 +25,4 @@ pub struct FlashOpts {
     /// Open a serial monitor after flashing
     #[clap(long)]
     pub monitor: bool,
-    /// Encrypt the flash contents
-    #[clap(long, conflicts_with = "ram")]
-    pub encrypt: bool,
-    /// Encryption key to encrypt the flash contents with
-    #[clap(long, requires = "encrypt")]
-    pub encryption_key: Option<String>,
 }

espflash/src/cli/mod.rs

@@ -2,7 +2,10 @@
 //!
 //! No stability guaranties apply
 
-use std::{fs, path::PathBuf};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
 
 use config::Config;
 use miette::{IntoDiagnostic, Result, WrapErr};
@@ -11,6 +14,7 @@ use serialport::{FlowControl, SerialPortType};
 use self::clap::ConnectOpts;
 use crate::{
     cli::serial::get_serial_port_info, error::Error, Chip, FirmwareImage, Flasher, ImageFormatId,
+    PartitionTable,
 };
 
 pub mod clap;
@@ -72,3 +76,45 @@ pub fn save_elf_as_image(
 
     Ok(())
 }
+
+pub fn flash_elf_image(
+    flasher: &mut Flasher,
+    elf_data: &[u8],
+    bootloader: Option<&Path>,
+    partition_table: Option<&Path>,
+    image_format: Option<ImageFormatId>,
+) -> Result<()> {
+    // If the '--bootloader' option is provided, load the binary file at the
+    // specified path.
+    let bootloader = if let Some(path) = bootloader {
+        let path = fs::canonicalize(path).into_diagnostic()?;
+        let data = fs::read(path).into_diagnostic()?;
+
+        Some(data)
+    } else {
+        None
+    };
+
+    // If the '--partition-table' option is provided, load the partition table from
+    // the CSV at the specified path.
+    let partition_table = if let Some(path) = partition_table {
+        let path = fs::canonicalize(path).into_diagnostic()?;
+        let data = fs::read_to_string(path)
+            .into_diagnostic()
+            .wrap_err("Failed to open partition table")?;
+
+        let table =
+            PartitionTable::try_from_str(data).wrap_err("Failed to parse partition table")?;
+
+        Some(table)
+    } else {
+        None
+    };
+
+    // Load the ELF data, optionally using the provider bootloader/partition
+    // table/image format, to the device's flash memory.
+    flasher.load_elf_to_flash_with_format(elf_data, bootloader, partition_table, image_format)?;
+    println!("\nFlashing has completed!");
+
+    Ok(())
+}

espflash/src/main.rs

@@ -1,20 +1,15 @@
-use std::{
-    fs::{self, read, read_to_string},
-    mem::swap,
-    path::PathBuf,
-    str::FromStr,
-};
+use std::{fs, mem::swap, path::PathBuf, str::FromStr};
 
 use clap::{AppSettings, IntoApp, Parser};
 use espflash::{
     cli::{
         board_info,
         clap::{ConnectOpts, FlashOpts},
-        connect,
+        connect, flash_elf_image,
         monitor::monitor,
         save_elf_as_image,
     },
-    Chip, Config, Error, ImageFormatId, PartitionTable,
+    Chip, Config, ImageFormatId,
 };
 use miette::{IntoDiagnostic, Result, WrapErr};
 
@@ -72,68 +67,43 @@ fn main() -> Result<()> {
         use SubCommand::*;
 
         match subcommand {
-            BoardInfo(matches) => board_info(matches, config),
-            SaveImage(matches) => save_image(matches),
+            BoardInfo(opts) => board_info(opts, config),
+            SaveImage(opts) => save_image(opts),
         }
     } else {
         flash(opts, config)
     }
 }
 
 fn flash(opts: Opts, config: Config) -> Result<()> {
-    let ram = opts.flash_opts.ram;
-    let bootloader_path = opts.flash_opts.bootloader;
-    let partition_table_path = opts.flash_opts.partition_table;
-    let image_format_string = opts.format;
-
-    let elf = match opts.image {
-        Some(elf) => elf,
-        _ => {
-            Opts::into_app().print_help().ok();
-            return Ok(());
-        }
-    };
-
     let mut flasher = connect(&opts.connect_opts, &config)?;
+    flasher.board_info()?;
 
-    let input_bytes = read(&elf)
-        .into_diagnostic()
-        .wrap_err_with(|| format!("Failed to open elf image \"{}\"", elf))?;
+    let elf = if let Some(elf) = opts.image {
+        elf
+    } else {
+        Opts::into_app().print_help().ok();
+        return Ok(());
+    };
+
+    // Read the ELF data from the build path and load it to the target.
+    let elf_data = fs::read(&elf).into_diagnostic()?;
 
-    if ram {
-        flasher.load_elf_to_ram(&input_bytes)?;
+    if opts.flash_opts.ram {
+        flasher.load_elf_to_ram(&elf_data)?;
     } else {
-        let bootloader = bootloader_path
-            .as_deref()
-            .map(read)
-            .transpose()
-            .into_diagnostic()
-            .wrap_err_with(|| {
-                format!(
-                    "Failed to open bootloader image \"{}\"",
-                    bootloader_path.unwrap().display()
-                )
-            })?;
-        let image_format = image_format_string
+        let bootloader = opts.flash_opts.bootloader.as_deref();
+        let partition_table = opts.flash_opts.partition_table.as_deref();
+
+        let image_format = opts
+            .format
             .as_deref()
             .map(ImageFormatId::from_str)
             .transpose()?;
-        let partition_table = partition_table_path
-            .as_deref()
-            .map(|path| {
-                let table = read_to_string(path)?;
-                PartitionTable::try_from_str(&table).map_err(Error::from)
-            })
-            .transpose()
-            .into_diagnostic()
-            .wrap_err_with(|| {
-                format!(
-                    "Failed to load partition table \"{}\"",
-                    partition_table_path.unwrap().display()
-                )
-            })?;
-        flasher.load_elf_to_flash_with_format(
-            &input_bytes,
+
+        flash_elf_image(
+            &mut flasher,
+            &elf_data,
             bootloader,
             partition_table,
             image_format,