| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use crate::args::StartCommand; |
| use crate::graphic_utils::get_default_graphics; |
| use crate::images::Images; |
| use crate::tools::Tools; |
| use anyhow::{anyhow, Result}; |
| use errors::ffx_bail; |
| use ffx_config::sdk::{Sdk, SdkVersion}; |
| use home::home_dir; |
| use mockall::automock; |
| use std::convert::From; |
| use std::env; |
| use std::fmt; |
| use std::fs::{create_dir, read_dir, File}; |
| use std::io::{BufRead, BufReader}; |
| use std::os::unix; |
| use std::path::PathBuf; |
| |
| pub fn read_env_path(var: &str) -> Result<PathBuf> { |
| env::var_os(var) |
| .map(PathBuf::from) |
| .ok_or(anyhow!("{} is not a valid environment variable", var)) |
| } |
| |
| #[automock] |
| pub trait FuchsiaPaths { |
| fn find_fuchsia_root(&mut self) -> Result<PathBuf>; |
| fn find_fuchsia_build_dir(&mut self) -> Result<PathBuf>; |
| fn get_tool_path(&mut self, name: &str) -> Result<PathBuf>; |
| fn get_image_path<'a>(&mut self, names: Vec<&'a str>, image_type: &str) -> Result<PathBuf>; |
| } |
| |
| pub struct InTreePaths { |
| pub root_dir: Option<PathBuf>, |
| pub build_dir: Option<PathBuf>, |
| } |
| |
| impl FuchsiaPaths for InTreePaths { |
| /// Walks the current execution path and its parent directories to find the path |
| /// that contains .jiri_root directory. |
| fn find_fuchsia_root(&mut self) -> Result<PathBuf> { |
| if self.root_dir.is_none() { |
| for ancester in std::env::current_exe()?.ancestors() { |
| if let Ok(entries) = read_dir(ancester) { |
| for entry in entries { |
| if let Ok(entry) = entry { |
| if entry.path().ends_with(".jiri_root") { |
| self.root_dir.replace(ancester.to_path_buf()); |
| println!( |
| "[fvdl] Found Fuchsia root directory {:?}", |
| self.root_dir.as_ref().unwrap().display() |
| ); |
| return Ok(ancester.to_path_buf()); |
| } |
| } |
| } |
| } |
| } |
| } |
| self.root_dir |
| .as_ref() |
| .map(|c| c.clone()) |
| .ok_or(anyhow!("Cannot locate Fuchsia binaries.\n\ |
| SDK users, make sure you include the --sdk flag and run the program from inside the Fuchsia SDK directory.\n\ |
| Non-SDK users, make sure you're running the program from inside the Fuchsia source directory tree.")) |
| } |
| |
| fn find_fuchsia_build_dir(&mut self) -> Result<PathBuf> { |
| if self.build_dir.is_none() { |
| match read_env_path("FUCHSIA_BUILD_DIR") { |
| Ok(val) => self.build_dir.replace(val), |
| _ => { |
| let root = self.find_fuchsia_root()?; |
| let build_dir = File::open(root.join(".fx-build-dir"))?; |
| let build_dir_file = BufReader::new(build_dir); |
| let dir = build_dir_file |
| .lines() |
| .nth(0) |
| .ok_or(anyhow!("cannot read file {:?}", root.join(".fx-build-dir")))?; |
| self.build_dir.replace(root.join(dir?)) |
| } |
| }; |
| } |
| self.build_dir |
| .as_ref() |
| .map(|c| c.clone()) |
| .ok_or(anyhow!("Cannot read path info from build_dir {:?}", self.build_dir)) |
| } |
| |
| fn get_tool_path(&mut self, name: &str) -> Result<PathBuf> { |
| let build_dir = self.find_fuchsia_build_dir()?; |
| let tools = Tools::from_build_dir(build_dir.clone())?; |
| tools.find_path(name).map(|p| build_dir.join(p)) |
| } |
| |
| fn get_image_path<'a>(&mut self, names: Vec<&'a str>, image_type: &str) -> Result<PathBuf> { |
| let build_dir = self.find_fuchsia_build_dir()?; |
| let images = Images::from_build_dir(build_dir.clone())?; |
| images.find_path(names, image_type).map(|p| build_dir.join(p)) |
| } |
| } |
| |
| /// Returns GN SDK tools directory. This assumes that fvdl is located in |
| /// <sdk_root>/tools/[x64|arm64]/fvdl, and will return path to <sdk_root>/tools/[x64|arm64] |
| pub fn get_fuchsia_sdk_tools_dir() -> Result<PathBuf> { |
| Ok(std::env::current_exe()? |
| .parent() |
| .ok_or(anyhow!("Cannot get parent path to 'fvdl'."))? |
| .to_path_buf()) |
| } |
| |
| /// Returns GN SDK tools directory. This assumes that fvdl is located in |
| /// <sdk_root>/tools/[x64|arm64]/fvdl, and will return path to <sdk_root> |
| pub fn get_fuchsia_sdk_dir() -> Result<PathBuf> { |
| Ok(get_fuchsia_sdk_tools_dir()? // ex: <sdk_root>/tools/x64/ |
| .parent() // ex: <sdk_root>/tools/ |
| .ok_or(anyhow!("Cannot get parent path to 'tools' directory."))? |
| .parent() // ex: <sdk_root> |
| .ok_or(anyhow!("Cannot get path to sdk root."))? |
| .to_path_buf()) |
| } |
| |
| /// Returns either the path specified in the environment variable FUCHSIA_SDK_DATA_DIR or |
| /// $HOME/.fuchsia |
| pub fn get_sdk_data_dir() -> Result<PathBuf> { |
| let sdk_data_dir = match read_env_path("FUCHSIA_SDK_DATA_DIR") { |
| Ok(dir) => dir, |
| _ => { |
| let default = home_dir().unwrap_or_default().join(".fuchsia"); |
| if !default.exists() { |
| create_dir(&default)?; |
| } |
| default |
| } |
| }; |
| Ok(sdk_data_dir) |
| } |
| |
| /// Reads sdk version from manifest.json. |
| /// This method assumes that user is invoking the binary from GN SDK, not in fuchsia repo. |
| /// TODO(fxb/69689) Use ffx::config to obtain host_tools location. |
| pub fn get_sdk_version_from_manifest() -> Result<String> { |
| let sdk = Sdk::from_sdk_dir(get_fuchsia_sdk_dir()?)?; |
| match sdk.get_version() { |
| SdkVersion::Version(v) => Ok(v.to_string()), |
| SdkVersion::InTree => ffx_bail!("This should only be used in SDK"), |
| SdkVersion::Unknown => ffx_bail!("Cannot determine SDK version"), |
| } |
| } |
| |
| #[derive(Clone)] |
| pub struct ImageFiles { |
| pub amber_files: Option<PathBuf>, |
| pub build_args: Option<PathBuf>, |
| pub fvm: Option<PathBuf>, |
| pub kernel: PathBuf, |
| pub zbi: PathBuf, |
| } |
| |
| impl fmt::Debug for ImageFiles { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| writeln!(f, "[fvdl] image package {:?}", self.amber_files)?; |
| writeln!(f, "[fvdl] image build_args {:?}", self.build_args)?; |
| writeln!(f, "[fvdl] image fvm {:?}", self.fvm)?; |
| writeln!(f, "[fvdl] image kernel {:?}", self.kernel)?; |
| write!(f, "[fvdl] image zbi {:?}", self.zbi) |
| } |
| } |
| |
| impl ImageFiles { |
| /// Initialize fuchsia image and package files for in-tree usage. |
| /// |
| /// First checks for environment variable FUCHSIA_BUILD_DIR. If not specify looks into |
| /// <repo_root>/.fx-build-dir. For example ~/fuchsia/.fx-build-dir |
| pub fn from_tree_env(f: &mut impl FuchsiaPaths) -> Result<Self> { |
| let fuchsia_build_dir = f.find_fuchsia_build_dir()?; |
| println!("[fvdl] Using fuchsia build dir: {:?}", fuchsia_build_dir.display()); |
| |
| Ok(Self { |
| amber_files: { |
| let f = fuchsia_build_dir.join("amber-files"); |
| if f.exists() { |
| Some(f) |
| } else { |
| None |
| } |
| }, |
| build_args: f.get_image_path(vec!["buildargs"], "gn").ok(), |
| fvm: f |
| .get_image_path(vec!["storage-full", "storage-sparse", "fvm.fastboot"], "blk") |
| .ok(), |
| kernel: f.get_image_path(vec!["qemu-kernel"], "kernel")?, |
| zbi: f.get_image_path(vec!["zircon-a"], "zbi")?, |
| }) |
| } |
| |
| /// When running from SDK (running with --sdk), we will either fetch images from GCS or use cached-image files. |
| /// If fetching from GCS, these image files will be ignored by device_launcher. |
| /// If using cached images, call update_paths_from_cache() to populate the image file paths. |
| pub fn from_sdk_env() -> Result<Self> { |
| Ok(Self { |
| amber_files: None, |
| build_args: None, |
| fvm: None, |
| kernel: PathBuf::new(), |
| zbi: PathBuf::new(), |
| }) |
| } |
| |
| /// Checks that all essential files exist. Note: amber_files, build_args, and fvm are optional. |
| pub fn check(&self) -> Result<()> { |
| if let Some(a) = &self.amber_files { |
| if !a.exists() { |
| ffx_bail!("amber-files at {:?} does not exist", a); |
| } |
| } |
| if let Some(b) = &self.build_args { |
| if !b.exists() { |
| ffx_bail!("build_args file at {:?} does not exist", b); |
| } |
| } |
| if let Some(f) = &self.fvm { |
| if !f.exists() { |
| ffx_bail!("fvm file at {:?} does not exist", f); |
| } |
| } |
| |
| if !self.kernel.exists() { |
| ffx_bail!("kernel file at {:?} does not exist", self.kernel); |
| } |
| if !self.zbi.exists() { |
| ffx_bail!("zbi file at {:?} does not exist", self.zbi); |
| } |
| Ok(()) |
| } |
| |
| pub fn images_exist(&self) -> bool { |
| return self.kernel.exists() |
| && self.zbi.exists() |
| && self.build_args.as_ref().map_or(true, |b| b.exists()) |
| && self.amber_files.as_ref().map_or(true, |a| a.exists()) |
| && self.fvm.as_ref().map_or(true, |f| f.exists()); |
| } |
| |
| pub fn update_paths_from_cache(&mut self, cache_root: &PathBuf) { |
| self.amber_files = Some(cache_root.join("package_archive")); |
| self.build_args = Some(cache_root.join("images").join("buildargs")); |
| self.fvm = Some(cache_root.join("images").join("femu-fvm")); |
| self.kernel = cache_root.join("images").join("femu-kernel"); |
| self.zbi = cache_root.join("images").join("zircon-a.zbi"); |
| } |
| |
| pub fn update_paths_from_args(&mut self, start_command: &StartCommand) { |
| if let Some(image) = &start_command.amber_files { |
| self.amber_files = Some(PathBuf::from(image)) |
| } |
| if let Some(image) = &start_command.fvm_image { |
| self.fvm = Some(PathBuf::from(image)) |
| } |
| if let Some(image) = &start_command.kernel_image { |
| self.kernel = PathBuf::from(image) |
| } |
| if let Some(image) = &start_command.zbi_image { |
| self.zbi = PathBuf::from(image) |
| } |
| } |
| |
| pub fn stage_files(&mut self, dir: &PathBuf) -> Result<()> { |
| let vdl_kernel_dest = dir.join("femu_kernel"); |
| let vdl_kernel_src = self.kernel.as_path(); |
| unix::fs::symlink(&vdl_kernel_src, &vdl_kernel_dest)?; |
| self.kernel = vdl_kernel_dest.to_path_buf(); |
| |
| if let Some(f) = &self.fvm { |
| let vdl_fvm_dest = dir.join("femu_fvm"); |
| let vdl_fvm_src = f.as_path(); |
| unix::fs::symlink(&vdl_fvm_src, &vdl_fvm_dest)?; |
| self.fvm = Some(vdl_fvm_dest.to_path_buf()); |
| } |
| |
| if let Some(f) = &self.build_args { |
| let vdl_args_dest = dir.join("femu_buildargs"); |
| let vdl_args_src = f.as_path(); |
| unix::fs::symlink(&vdl_args_src, &vdl_args_dest)?; |
| self.build_args = Some(vdl_args_dest.to_path_buf()); |
| } |
| Ok(()) |
| } |
| } |
| |
| #[derive(Clone)] |
| pub struct SSHKeys { |
| pub authorized_keys: PathBuf, |
| pub private_key: PathBuf, |
| } |
| |
| impl fmt::Debug for SSHKeys { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| writeln!(f, "[fvdl] private_key {:?}", self.private_key)?; |
| write!(f, "[fvdl] authorized_keys {:?}", self.authorized_keys) |
| } |
| } |
| |
| impl SSHKeys { |
| /// Initialize SSH key files for in-tree usage. |
| /// |
| /// Requires the environment variable FUCHSIA_BUILD_DIR to be specified. |
| pub fn from_tree_env(f: &mut impl FuchsiaPaths) -> Result<Self> { |
| let ssh_file = File::open(f.find_fuchsia_root()?.join(".fx-ssh-path"))?; |
| let ssh_file = BufReader::new(ssh_file); |
| let mut lines = ssh_file.lines(); |
| |
| let private_key = PathBuf::from(lines.next().unwrap()?); |
| let authorized_keys = PathBuf::from(lines.next().unwrap()?); |
| Ok(Self { authorized_keys: authorized_keys, private_key: private_key }) |
| } |
| |
| /// Initialize SSH key files for GN SDK usage. |
| /// |
| /// Requires SSH keys to have been generated and stored in $HOME/.ssh/... |
| pub fn from_sdk_env() -> Result<Self> { |
| Ok(Self { |
| authorized_keys: home_dir().unwrap_or_default().join(".ssh/fuchsia_authorized_keys"), |
| private_key: home_dir().unwrap_or_default().join(".ssh/fuchsia_ed25519"), |
| }) |
| } |
| |
| pub fn check(&self) -> Result<()> { |
| if !self.private_key.exists() { |
| ffx_bail!("private_key file at {:?} does not exist", self.private_key); |
| } |
| if !self.authorized_keys.exists() { |
| ffx_bail!("authorized_keys file at {:?} does not exist", self.authorized_keys); |
| } |
| Ok(()) |
| } |
| |
| pub fn update_paths_from_args(&mut self, start_command: &StartCommand) { |
| if let Some(path) = &start_command.ssh { |
| let ssh_path = PathBuf::from(path); |
| self.authorized_keys = ssh_path.join("fuchsia_authorized_keys").to_path_buf(); |
| self.private_key = ssh_path.join("fuchsia_ed25519").to_path_buf(); |
| } |
| } |
| |
| pub fn stage_files(&mut self, dir: &PathBuf) -> Result<()> { |
| let vdl_priv_key_dest = dir.join("id_ed25519"); |
| let vdl_priv_key_src = self.private_key.as_path(); |
| unix::fs::symlink(&vdl_priv_key_src, &vdl_priv_key_dest)?; |
| self.private_key = vdl_priv_key_dest.to_path_buf(); |
| |
| let vdl_authorized_keys_dest = dir.join("fuchsia_authorized_keys"); |
| let vdl_authorized_keys_src = self.authorized_keys.as_path(); |
| unix::fs::symlink(&vdl_authorized_keys_src, &vdl_authorized_keys_dest)?; |
| self.authorized_keys = vdl_authorized_keys_dest.to_path_buf(); |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Debug)] |
| pub struct VDLArgs { |
| pub headless: bool, |
| pub tuntap: bool, |
| pub enable_grpcwebproxy: bool, |
| pub enable_hidpi_scaling: bool, |
| pub grpcwebproxy_port: String, |
| pub upscript: String, |
| pub start_package_server: bool, |
| pub packages_to_serve: String, |
| pub device_proto: String, |
| pub gpu: String, |
| pub gcs_bucket: String, |
| pub gcs_image_archive: String, |
| pub sdk_version: String, |
| pub cache_root: PathBuf, |
| pub extra_kerel_args: String, |
| pub amber_unpack_root: String, |
| pub package_server_port: String, |
| pub acceleration: bool, |
| pub image_architecture: String, |
| pub isolated_ffx_config_path: String, |
| } |
| |
| impl From<&StartCommand> for VDLArgs { |
| fn from(cmd: &StartCommand) -> Self { |
| let mut gpu = get_default_graphics(); |
| if cmd.host_gpu { |
| gpu = "host".to_string(); |
| } else if cmd.software_gpu { |
| gpu = "swiftshader_indirect".to_string(); |
| } |
| |
| let mut enable_grpcwebproxy = false; |
| let mut grpcwebproxy_port = "0".to_string(); |
| |
| match cmd.grpcwebproxy { |
| Some(port) => { |
| enable_grpcwebproxy = true; |
| grpcwebproxy_port = format!("{}", port); |
| } |
| _ => (), |
| } |
| let gcs_image = cmd.image_name.as_ref().unwrap_or(&String::from("qemu-x64")).to_string(); |
| let sdk_version = match &cmd.sdk_version { |
| Some(version) => version.to_string(), |
| None => match get_sdk_version_from_manifest() { |
| Ok(version) => version, |
| Err(_) => String::from(""), |
| }, |
| }; |
| let mut cache_path = PathBuf::new(); |
| if cmd.cache_image { |
| cache_path = get_sdk_data_dir().unwrap_or_default().join(&gcs_image).join(&sdk_version); |
| } |
| VDLArgs { |
| headless: cmd.headless, |
| tuntap: cmd.tuntap, |
| enable_hidpi_scaling: cmd.hidpi_scaling, |
| upscript: cmd.upscript.as_ref().unwrap_or(&String::from("")).to_string(), |
| start_package_server: cmd.start_package_server, |
| packages_to_serve: cmd |
| .packages_to_serve |
| .as_ref() |
| .unwrap_or(&String::from("")) |
| .to_string(), |
| device_proto: cmd.device_proto.as_ref().unwrap_or(&String::from("")).to_string(), |
| gpu: gpu, |
| enable_grpcwebproxy: enable_grpcwebproxy, |
| grpcwebproxy_port: grpcwebproxy_port, |
| gcs_bucket: cmd.gcs_bucket.as_ref().unwrap_or(&String::from("fuchsia")).to_string(), |
| gcs_image_archive: gcs_image, |
| sdk_version: sdk_version, |
| cache_root: cache_path, |
| extra_kerel_args: cmd.kernel_args.as_ref().unwrap_or(&String::from("")).to_string(), |
| amber_unpack_root: cmd |
| .amber_unpack_root |
| .as_ref() |
| .unwrap_or(&String::from("")) |
| .to_string(), |
| package_server_port: cmd.package_server_port.as_ref().unwrap_or(&0).to_string(), |
| acceleration: !cmd.noacceleration, |
| image_architecture: cmd |
| .image_architecture |
| .as_ref() |
| .unwrap_or(&String::from("")) |
| .to_string(), |
| isolated_ffx_config_path: cmd |
| .isolated_ffx_config_path |
| .as_ref() |
| .unwrap_or(&String::from("")) |
| .to_string(), |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use serial_test::serial; |
| use std::io::Write; |
| use tempfile::Builder; |
| |
| #[test] |
| fn test_convert_start_cmd_to_vdl() { |
| let start_command = &StartCommand { |
| tuntap: true, |
| upscript: Some("/path/to/upscript".to_string()), |
| packages_to_serve: Some("pkg1.far,pkg2.far".to_string()), |
| host_gpu: true, |
| aemu_version: Some("git_revision:da1cc2ee512714a176f08b8b5fec035994ca305d".to_string()), |
| sdk_version: Some("0.20201130.3.1".to_string()), |
| image_name: Some("qemu-x64".to_string()), |
| package_server_log: Some("/a/b/c/server.log".to_string()), |
| envs: Vec::new(), |
| cache_image: true, |
| isolated_ffx_config_path: Some("/a/b/c/isolated_config.txt".to_string()), |
| ..Default::default() |
| }; |
| let vdl_args: VDLArgs = start_command.into(); |
| assert_eq!(vdl_args.headless, false); |
| assert_eq!(vdl_args.tuntap, true); |
| assert_eq!(vdl_args.upscript, "/path/to/upscript"); |
| assert_eq!(vdl_args.packages_to_serve, "pkg1.far,pkg2.far"); |
| assert_eq!(vdl_args.device_proto, ""); |
| assert_eq!(vdl_args.gpu, "host"); |
| assert_eq!(vdl_args.start_package_server, false); |
| assert_eq!(vdl_args.acceleration, true); |
| assert_eq!(vdl_args.package_server_port, "0"); |
| assert_eq!(vdl_args.amber_unpack_root, ""); |
| assert_eq!(vdl_args.isolated_ffx_config_path, "/a/b/c/isolated_config.txt"); |
| assert!(vdl_args.cache_root.as_path().ends_with("qemu-x64/0.20201130.3.1")); |
| } |
| |
| #[test] |
| #[serial] |
| fn test_image_intree_files() -> Result<()> { |
| env::remove_var("FUCHSIA_BUILD_DIR"); |
| let mut mock = MockFuchsiaPaths::new(); |
| let data = format!( |
| "/build/out |
| ", |
| ); |
| let tmp_dir = Builder::new().prefix("fvdl_tests_").tempdir()?; |
| let a = tmp_dir.into_path(); |
| let b = a.join("/build/out"); |
| File::create(a.join(".fx-build-dir"))?.write_all(data.as_bytes())?; |
| mock.expect_find_fuchsia_root().returning(move || Ok(a.clone())); |
| mock.expect_find_fuchsia_build_dir().returning(move || Ok(b.clone())); |
| mock.expect_get_image_path().returning(|name: Vec<&str>, _: &str| { |
| let mut p = PathBuf::from("/build/out"); |
| p.push(name[0]); |
| Ok(p) |
| }); |
| |
| let mut image_files = ImageFiles::from_tree_env(&mut mock)?; |
| assert_eq!(image_files.zbi.to_str().unwrap(), "/build/out/zircon-a"); |
| assert_eq!(image_files.kernel.to_str().unwrap(), "/build/out/qemu-kernel"); |
| assert_eq!(image_files.fvm.as_ref().unwrap().to_str().unwrap(), "/build/out/storage-full"); |
| assert_eq!( |
| image_files.build_args.as_ref().unwrap().to_str().unwrap(), |
| "/build/out/buildargs" |
| ); |
| // amber_files are optional and is only specified if the file exists. For unit test |
| // the file always does not exit. |
| assert_eq!(image_files.amber_files, None); |
| |
| image_files.update_paths_from_args(&StartCommand { |
| fvm_image: Some("/path/to/new_fvm".to_string()), |
| zbi_image: Some("/path/to/new_zbi".to_string()), |
| kernel_image: Some("/path/to/new_kernel".to_string()), |
| amber_files: Some("/path/to/amber_files".to_string()), |
| ..Default::default() |
| }); |
| assert_eq!(image_files.zbi.to_str().unwrap(), "/path/to/new_zbi"); |
| assert_eq!(image_files.kernel.to_str().unwrap(), "/path/to/new_kernel"); |
| assert_eq!(image_files.fvm.as_ref().unwrap().to_str().unwrap(), "/path/to/new_fvm"); |
| assert_eq!( |
| image_files.amber_files.as_ref().unwrap().to_str().unwrap(), |
| "/path/to/amber_files" |
| ); |
| assert_eq!( |
| image_files.build_args.as_ref().unwrap().to_str().unwrap(), |
| "/build/out/buildargs" |
| ); |
| let tmp_dir = Builder::new().prefix("fvdl_tests_").tempdir()?; |
| |
| image_files.stage_files(&tmp_dir.path().to_owned())?; |
| assert_eq!(image_files.kernel.to_str(), tmp_dir.path().join("femu_kernel").to_str()); |
| assert_eq!( |
| image_files.fvm.as_ref().unwrap().to_str(), |
| tmp_dir.path().join("femu_fvm").to_str() |
| ); |
| Ok(()) |
| } |
| |
| #[test] |
| #[serial] |
| fn test_image_sdk_files() -> Result<()> { |
| let mut image_files = ImageFiles::from_sdk_env()?; |
| image_files.update_paths_from_args(&StartCommand { |
| amber_files: Some("/path/to/amber_files".to_string()), |
| fvm_image: Some("/path/to/new_fvm".to_string()), |
| kernel_image: Some("/path/to/new_kernel".to_string()), |
| zbi_image: Some("/path/to/new_zbi".to_string()), |
| ..Default::default() |
| }); |
| assert_eq!( |
| image_files.amber_files.as_ref().unwrap().to_str().unwrap(), |
| "/path/to/amber_files" |
| ); |
| assert_eq!(image_files.build_args, None); |
| assert_eq!(image_files.fvm.as_ref().unwrap().to_str().unwrap(), "/path/to/new_fvm"); |
| assert_eq!(image_files.kernel.to_str().unwrap(), "/path/to/new_kernel"); |
| assert_eq!(image_files.zbi.to_str().unwrap(), "/path/to/new_zbi"); |
| |
| let tmp_dir = Builder::new().prefix("fvdl_tests_").tempdir()?; |
| image_files.stage_files(&tmp_dir.path().to_owned())?; |
| assert_eq!(image_files.kernel.to_str(), tmp_dir.path().join("femu_kernel").to_str()); |
| assert_eq!( |
| image_files.fvm.as_ref().unwrap().to_str(), |
| tmp_dir.path().join("femu_fvm").to_str() |
| ); |
| assert_eq!(image_files.build_args, None); |
| Ok(()) |
| } |
| |
| #[test] |
| #[serial] |
| fn test_ssh_files() -> Result<()> { |
| let mut mock = MockFuchsiaPaths::new(); |
| let data = format!( |
| "/usr/local/home/foo/.ssh/fuchsia_ed25519 |
| /usr/local/home/foo/.ssh/fuchsia_authorized_keys |
| ", |
| ); |
| let tmp_dir = Builder::new().prefix("fvdl_tests_").tempdir()?; |
| let a = tmp_dir.into_path(); |
| File::create(a.join(".fx-ssh-path"))?.write_all(data.as_bytes())?; |
| mock.expect_find_fuchsia_root().returning(move || Ok(a.clone())); |
| let mut ssh_files = SSHKeys::from_tree_env(&mut mock)?; |
| assert_eq!( |
| ssh_files.private_key.to_str().unwrap(), |
| "/usr/local/home/foo/.ssh/fuchsia_ed25519" |
| ); |
| assert_eq!( |
| ssh_files.authorized_keys.to_str().unwrap(), |
| "/usr/local/home/foo/.ssh/fuchsia_authorized_keys" |
| ); |
| let tmp_dir = Builder::new().prefix("fvdl_test_ssh_").tempdir()?; |
| ssh_files.stage_files(&tmp_dir.path().to_owned())?; |
| assert!(ssh_files.private_key.ends_with("id_ed25519")); |
| Ok(()) |
| } |
| |
| #[test] |
| #[serial] |
| fn test_ssh_dir() -> Result<()> { |
| let mut ssh_files = SSHKeys::from_sdk_env()?; |
| assert_eq!( |
| ssh_files.private_key, |
| home_dir().unwrap_or_default().join(".ssh/fuchsia_ed25519") |
| ); |
| assert_eq!( |
| ssh_files.authorized_keys, |
| home_dir().unwrap_or_default().join(".ssh/fuchsia_authorized_keys") |
| ); |
| |
| ssh_files.update_paths_from_args(&StartCommand { |
| ssh: Some("/path/to/ssh".to_string()), |
| ..Default::default() |
| }); |
| |
| assert_eq!(ssh_files.private_key.to_str().unwrap(), "/path/to/ssh/fuchsia_ed25519"); |
| assert_eq!( |
| ssh_files.authorized_keys.to_str().unwrap(), |
| "/path/to/ssh/fuchsia_authorized_keys" |
| ); |
| Ok(()) |
| } |
| |
| #[test] |
| #[serial] |
| fn test_sdk_data_dir() -> Result<()> { |
| let tmp_dir = Builder::new().prefix("fvdl_test_sdk_data_dir_").tempdir()?; |
| env::set_var("FUCHSIA_SDK_DATA_DIR", tmp_dir.path()); |
| let p = get_sdk_data_dir()?; |
| assert_eq!(p.to_str(), tmp_dir.path().to_str()); |
| Ok(()) |
| } |
| } |
