Added support for extensions (#4)

* Added support for extensions

* Removed re-parse

* Pass runtime instead of getting it from metadata

Author: zeitue

src/main.rs

@@ -108,29 +108,34 @@ fn run(run: RunCommand, verbose: bool) -> anyhow::Result<ExitCode> {
     let available_runtimes =
         list_available_runtimes(&install_dirs).context("Could not list runtimes")?;
 
-    let (runtime, app_files_path) = match (&run.app, run.runtime) {
+    let raw_app_metadata: Option<String>;
+    let (runtime, app_files_path, app_metadata) = match (&run.app, run.runtime) {
         (Some(app), None) => {
             let app_path = find_install_path(app, true, &install_dirs)
                 .context("Could not find app install dir")?
                 .join("current")
                 .join("active");
             let app_metadata_path = app_path.join("metadata");
 
-            let raw_app_metadata =
-                fs::read_to_string(app_metadata_path).context("Could not read app metadata")?;
-            let app_metadata =
-                parse_keyfile(&raw_app_metadata).context("Could not parse app metadata")?;
+            raw_app_metadata = Some(
+                fs::read_to_string(app_metadata_path).context("Could not read app metadata")?,
+            );
+            let app_metadata = parse_keyfile(raw_app_metadata.as_ref().unwrap())
+                .context("Could not parse app metadata")?;
 
             let app_runtime = app_metadata
                 .get("Application")
                 .and_then(|app| app.get("runtime"))
-                .context("Could not read app runtime")?;
+                .context("Could not read app runtime")?
+                .to_string();
 
             let app_files_path = app_path.join("files");
 
-            (app_runtime.to_string(), Some(app_files_path))
+            (app_runtime, Some(app_files_path), Some(app_metadata))
+        }
+        (None, Some(runtime)) => {
+            (runtime, None, None)
         }
-        (None, Some(runtime)) => (runtime, None),
         (Some(_), Some(_)) => bail!("Only app or runtime flags can be used at once"),
         (None, None) => bail!("Either app or runtime has to be specified"),
     };
@@ -165,6 +170,16 @@ fn run(run: RunCommand, verbose: bool) -> anyhow::Result<ExitCode> {
         &install_dirs,
     )?;
 
+    if let Some(ref app_meta) = app_metadata {
+        setup_app_extensions(
+            &mut bwrap,
+            app_meta,
+            &runtime,
+            &available_runtimes,
+            &install_dirs,
+        )?;
+    }
+
     add_ld_so_conf(&mut bwrap)?;
 
     setup_env(&mut bwrap, runtime_env, run.app.as_deref());
@@ -283,6 +298,7 @@ fn setup_runtime_extensions(
                 version,
                 available_runtimes,
                 install_dirs,
+                Path::new("/usr"),
             )
             .with_context(|| format!("Could not set up extension {extension}"))?;
         }
@@ -291,6 +307,40 @@ fn setup_runtime_extensions(
     Ok(())
 }
 
+fn setup_app_extensions(
+    bwrap: &mut BwrapBuilder,
+    app_metadata: &IndexMap<&str, IndexMap<&str, &str>>,
+    runtime: &str,
+    available_runtimes: &[String],
+    install_dirs: &[PathBuf],
+) -> anyhow::Result<()> {
+    let mut runtime_split = runtime.split('/').skip(1);
+    let arch = runtime_split
+        .next()
+        .context("Could not extract architecture from runtime id")?;
+    let version = runtime_split
+        .next()
+        .context("Could not extract version from runtime id")?;
+
+    for (group, metadata) in app_metadata {
+        if let Some(extension) = group.strip_prefix(EXTENSION_PREFIX) {
+            setup_extension(
+                metadata,
+                bwrap,
+                extension,
+                arch,
+                version,
+                available_runtimes,
+                install_dirs,
+                Path::new("/app"),
+            )
+            .with_context(|| format!("Could not set up app extension {extension}"))?;
+        }
+    }
+
+    Ok(())
+}
+
 fn setup_extension(
     extension_metadata: &IndexMap<&str, &str>,
     bwrap: &mut BwrapBuilder,
@@ -299,13 +349,14 @@ fn setup_extension(
     runtime_version: &str,
     available_runtimes: &[String],
     install_dirs: &[PathBuf],
+    base_path: &Path,
 ) -> anyhow::Result<()> {
     let directory = extension_metadata
         .get("directory")
         .context("Missing directory")?;
 
     let expected_prefix = format!("{name}.");
-    let extension_base_mount_path = Path::new("/usr").join(directory);
+    let extension_base_mount_path = base_path.join(directory);
 
     let allowed_versions = extension_metadata
         .get("versions")