appmgr: initialize dependency errors on install

appmgr/src/dependencies.rs

@@ -136,7 +136,6 @@ impl DepInfo {
         dependency_config: Option<Config>, // fetch if none
         dependent_id: &PackageId,
         dependent_version: &Version,
-        dependent_config: &Config,
     ) -> Result<Result<(), DependencyError>, Error> {
         let dependency = crate::db::DatabaseModel::new()
             .package_data()
@@ -178,7 +177,7 @@ impl DepInfo {
         };
         if let Some(cfg_req) = &self.config {
             if let Err(e) = cfg_req
-                .check(dependent_id, dependent_version, dependent_config)
+                .check(dependent_id, dependent_version, &dependency_config)
                 .await
             {
                 if e.kind == crate::ErrorKind::ConfigRulesViolation {

appmgr/src/install/mod.rs

@@ -354,12 +354,25 @@ pub async fn install_s9pk<R: AsyncRead + AsyncSeek + Unpin>(
     log::info!("Install {}@{}: Complete", pkg_id, version);
 
     let static_files = StaticFiles::local(pkg_id, version, manifest.assets.icon_type())?;
+    let current_dependencies = manifest
+        .dependencies
+        .0
+        .iter()
+        .filter_map(|(id, info)| {
+            if info.optional.is_none() {
+                Some((id.clone(), CurrentDependencyInfo::default()))
+            } else {
+                None
+            }
+        })
+        .collect();
     let installed = InstalledPackageDataEntry {
         manifest: manifest.clone(),
         status: Status {
             configured: manifest.config.is_none(),
             main: MainStatus::Stopped,
-            dependency_errors: todo!(),
+            dependency_errors: DependencyErrors::init(&mut tx, &manifest, &current_dependencies)
+                .await?,
         },
         system_pointers: Vec::new(),
         current_dependents: {
@@ -386,18 +399,7 @@ pub async fn install_s9pk<R: AsyncRead + AsyncSeek + Unpin>(
             }
             deps
         },
-        current_dependencies: manifest
+        current_dependencies,
-            .dependencies
-            .0
-            .iter()
-            .filter_map(|(id, info)| {
-                if info.optional.is_none() {
-                    Some((id.clone(), CurrentDependencyInfo::default()))
-                } else {
-                    None
-                }
-            })
-            .collect(),
         interface_info,
     };
     let mut pde = model.get_mut(&mut tx).await?;

appmgr/src/status/mod.rs

@@ -415,6 +415,31 @@ impl HasModel for DependencyErrors {
     type Model = MapModel<Self>;
 }
 impl DependencyErrors {
+    pub async fn init<Db: DbHandle>(
+        db: &mut Db,
+        manifest: &Manifest,
+        current_dependencies: &IndexMap<PackageId, CurrentDependencyInfo>,
+    ) -> Result<DependencyErrors, Error> {
+        let mut res = IndexMap::new();
+        for (dep_id, info) in current_dependencies {
+            if let Err(e) = manifest
+                .dependencies
+                .0
+                .get(dep_id)
+                .ok_or_else(|| {
+                    Error::new(
+                        anyhow!("current dependency not in manifest"),
+                        crate::ErrorKind::Dependency,
+                    )
+                })?
+                .satisfied(db, dep_id, None, &manifest.id, &manifest.version)
+                .await?
+            {
+                res.insert(dep_id.clone(), e);
+            }
+        }
+        Ok(DependencyErrors(res))
+    }
     async fn update_health_based(
         &mut self,
         dependencies: &IndexMap<PackageId, CurrentDependencyInfo>,

appmgr/src/version/v0_2_13.rs

@@ -1,21 +0,0 @@
-use super::*;
-
-const V0_2_13: emver::Version = emver::Version::new(0, 2, 13, 0);
-
-pub struct Version;
-#[async_trait]
-impl VersionT for Version {
-    type Previous = v0_2_12::Version;
-    fn new() -> Self {
-        Version
-    }
-    fn semver(&self) -> &'static emver::Version {
-        &V0_2_13
-    }
-    async fn up(&self) -> Result<(), Error> {
-        Ok(())
-    }
-    async fn down(&self) -> Result<(), Error> {
-        Ok(())
-    }
-}