rename frontend to web and update contributing guide (#2509)

* rename frontend to web and update contributing guide

* rename this time

* fix build

* restructure rust code

* update documentation

* update descriptions

* Update CONTRIBUTING.md

Co-authored-by: J H <2364004+Blu-J@users.noreply.github.com>

---------

Co-authored-by: Aiden McClelland <me@drbonez.dev>
Co-authored-by: Aiden McClelland <3732071+dr-bonez@users.noreply.github.com>
Co-authored-by: J H <2364004+Blu-J@users.noreply.github.com>

core/startos/src/version/mod.rs

@@ -0,0 +1,229 @@
+use std::cmp::Ordering;
+
+use async_trait::async_trait;
+use color_eyre::eyre::eyre;
+use rpc_toolkit::command;
+use sqlx::PgPool;
+
+use crate::prelude::*;
+use crate::Error;
+
+mod v0_3_4;
+mod v0_3_4_1;
+mod v0_3_4_2;
+mod v0_3_4_3;
+mod v0_3_4_4;
+mod v0_3_5;
+
+pub type Current = v0_3_5::Version;
+
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+#[serde(untagged)]
+enum Version {
+    V0_3_4(Wrapper<v0_3_4::Version>),
+    V0_3_4_1(Wrapper<v0_3_4_1::Version>),
+    V0_3_4_2(Wrapper<v0_3_4_2::Version>),
+    V0_3_4_3(Wrapper<v0_3_4_3::Version>),
+    V0_3_4_4(Wrapper<v0_3_4_4::Version>),
+    V0_3_5(Wrapper<v0_3_5::Version>),
+    Other(emver::Version),
+}
+
+impl Version {
+    fn from_util_version(version: crate::util::Version) -> Self {
+        serde_json::to_value(version.clone())
+            .and_then(serde_json::from_value)
+            .unwrap_or_else(|_e| {
+                tracing::warn!("Can't deserialize: {:?} and falling back to other", version);
+                Version::Other(version.into_version())
+            })
+    }
+    #[cfg(test)]
+    fn as_sem_ver(&self) -> emver::Version {
+        match self {
+            Version::V0_3_4(Wrapper(x)) => x.semver(),
+            Version::V0_3_4_1(Wrapper(x)) => x.semver(),
+            Version::V0_3_4_2(Wrapper(x)) => x.semver(),
+            Version::V0_3_4_3(Wrapper(x)) => x.semver(),
+            Version::V0_3_4_4(Wrapper(x)) => x.semver(),
+            Version::V0_3_5(Wrapper(x)) => x.semver(),
+            Version::Other(x) => x.clone(),
+        }
+    }
+}
+
+#[async_trait]
+pub trait VersionT
+where
+    Self: Sized + Send + Sync,
+{
+    type Previous: VersionT;
+    fn new() -> Self;
+    fn semver(&self) -> emver::Version;
+    fn compat(&self) -> &'static emver::VersionRange;
+    async fn up(&self, db: PatchDb, secrets: &PgPool) -> Result<(), Error>;
+    async fn down(&self, db: PatchDb, secrets: &PgPool) -> Result<(), Error>;
+    async fn commit(&self, db: PatchDb) -> Result<(), Error> {
+        let semver = self.semver().into();
+        let compat = self.compat().clone();
+        db.mutate(|d| {
+            d.as_server_info_mut().as_version_mut().ser(&semver)?;
+            d.as_server_info_mut()
+                .as_eos_version_compat_mut()
+                .ser(&compat)?;
+            Ok(())
+        })
+        .await?;
+        Ok(())
+    }
+    async fn migrate_to<V: VersionT>(
+        &self,
+        version: &V,
+        db: PatchDb,
+        secrets: &PgPool,
+    ) -> Result<(), Error> {
+        match self.semver().cmp(&version.semver()) {
+            Ordering::Greater => self.rollback_to_unchecked(version, db, secrets).await,
+            Ordering::Less => version.migrate_from_unchecked(self, db, secrets).await,
+            Ordering::Equal => Ok(()),
+        }
+    }
+    async fn migrate_from_unchecked<V: VersionT>(
+        &self,
+        version: &V,
+        db: PatchDb,
+        secrets: &PgPool,
+    ) -> Result<(), Error> {
+        let previous = Self::Previous::new();
+        if version.semver() < previous.semver() {
+            previous
+                .migrate_from_unchecked(version, db.clone(), secrets)
+                .await?;
+        } else if version.semver() > previous.semver() {
+            return Err(Error::new(
+                eyre!(
+                    "NO PATH FROM {}, THIS IS LIKELY A MISTAKE IN THE VERSION DEFINITION",
+                    version.semver()
+                ),
+                crate::ErrorKind::MigrationFailed,
+            ));
+        }
+        tracing::info!("{} -> {}", previous.semver(), self.semver(),);
+        self.up(db.clone(), secrets).await?;
+        self.commit(db).await?;
+        Ok(())
+    }
+    async fn rollback_to_unchecked<V: VersionT>(
+        &self,
+        version: &V,
+        db: PatchDb,
+        secrets: &PgPool,
+    ) -> Result<(), Error> {
+        let previous = Self::Previous::new();
+        tracing::info!("{} -> {}", self.semver(), previous.semver(),);
+        self.down(db.clone(), secrets).await?;
+        previous.commit(db.clone()).await?;
+        if version.semver() < previous.semver() {
+            previous.rollback_to_unchecked(version, db, secrets).await?;
+        } else if version.semver() > previous.semver() {
+            return Err(Error::new(
+                eyre!(
+                    "NO PATH TO {}, THIS IS LIKELY A MISTAKE IN THE VERSION DEFINITION",
+                    version.semver()
+                ),
+                crate::ErrorKind::MigrationFailed,
+            ));
+        }
+        Ok(())
+    }
+}
+#[derive(Debug, Clone)]
+struct Wrapper<T>(T);
+impl<T> serde::Serialize for Wrapper<T>
+where
+    T: VersionT,
+{
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.0.semver().serialize(serializer)
+    }
+}
+impl<'de, T> serde::Deserialize<'de> for Wrapper<T>
+where
+    T: VersionT,
+{
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let v = crate::util::Version::deserialize(deserializer)?;
+        let version = T::new();
+        if *v == version.semver() {
+            Ok(Wrapper(version))
+        } else {
+            Err(serde::de::Error::custom("Mismatched Version"))
+        }
+    }
+}
+
+pub async fn init(db: &PatchDb, secrets: &PgPool) -> Result<(), Error> {
+    let version = Version::from_util_version(db.peek().await.as_server_info().as_version().de()?);
+
+    match version {
+        Version::V0_3_4(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::V0_3_4_1(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::V0_3_4_2(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::V0_3_4_3(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::V0_3_4_4(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::V0_3_5(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::Other(_) => {
+            return Err(Error::new(
+                eyre!("Cannot downgrade"),
+                crate::ErrorKind::InvalidRequest,
+            ))
+        }
+    }
+    Ok(())
+}
+
+pub const COMMIT_HASH: &str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../GIT_HASH.txt"));
+
+#[command(rename = "git-info", local, metadata(authenticated = false))]
+pub fn git_info() -> Result<&'static str, Error> {
+    Ok(COMMIT_HASH)
+}
+
+#[cfg(test)]
+mod tests {
+    use proptest::prelude::*;
+
+    use super::*;
+
+    fn em_version() -> impl Strategy<Value = emver::Version> {
+        any::<(usize, usize, usize, usize)>().prop_map(|(major, minor, patch, super_minor)| {
+            emver::Version::new(major, minor, patch, super_minor)
+        })
+    }
+
+    fn versions() -> impl Strategy<Value = Version> {
+        prop_oneof![
+            Just(Version::V0_3_4(Wrapper(v0_3_4::Version::new()))),
+            Just(Version::V0_3_4_1(Wrapper(v0_3_4_1::Version::new()))),
+            Just(Version::V0_3_4_2(Wrapper(v0_3_4_2::Version::new()))),
+            Just(Version::V0_3_4_3(Wrapper(v0_3_4_3::Version::new()))),
+            em_version().prop_map(Version::Other),
+        ]
+    }
+
+    proptest! {
+        #[test]
+        fn emversion_isomorphic_version(original in em_version()) {
+            let version = Version::from_util_version(original.clone().into());
+            let back = version.as_sem_ver();
+            prop_assert_eq!(original, back, "All versions should round trip");
+        }
+        #[test]
+        fn version_isomorphic_em_version(version in versions()) {
+            let sem_ver = version.as_sem_ver();
+            let back = Version::from_util_version(sem_ver.into());
+            prop_assert_eq!(format!("{:?}",version), format!("{:?}", back), "All versions should round trip");
+        }
+    }
+}

core/startos/src/version/v0_3_4.rs

@@ -0,0 +1,135 @@
+use async_trait::async_trait;
+use emver::VersionRange;
+use itertools::Itertools;
+use openssl::hash::MessageDigest;
+use serde_json::json;
+use ssh_key::public::Ed25519PublicKey;
+
+use super::*;
+use crate::account::AccountInfo;
+use crate::hostname::{sync_hostname, Hostname};
+use crate::prelude::*;
+
+const V0_3_4: emver::Version = emver::Version::new(0, 3, 4, 0);
+
+lazy_static::lazy_static! {
+    pub static ref V0_3_0_COMPAT: VersionRange = VersionRange::Conj(
+        Box::new(VersionRange::Anchor(
+            emver::GTE,
+            emver::Version::new(0, 3, 0, 0),
+        )),
+        Box::new(VersionRange::Anchor(emver::LTE, Current::new().semver())),
+    );
+}
+
+const COMMUNITY_URL: &str = "https://community-registry.start9.com/";
+const MAIN_REGISTRY: &str = "https://registry.start9.com/";
+const COMMUNITY_SERVICES: &[&str] = &[
+    "ipfs",
+    "agora",
+    "lightning-jet",
+    "balanceofsatoshis",
+    "mastodon",
+    "lndg",
+    "robosats",
+    "thunderhub",
+    "syncthing",
+    "sphinx-relay",
+];
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = Self;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_4
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &*V0_3_0_COMPAT
+    }
+    async fn up(&self, db: PatchDb, secrets: &PgPool) -> Result<(), Error> {
+        let mut account = AccountInfo::load(secrets).await?;
+        let account = db
+            .mutate(|d| {
+                d.as_server_info_mut().as_pubkey_mut().ser(
+                    &ssh_key::PublicKey::from(Ed25519PublicKey::from(&account.key.ssh_key()))
+                        .to_openssh()?,
+                )?;
+                d.as_server_info_mut().as_ca_fingerprint_mut().ser(
+                    &account
+                        .root_ca_cert
+                        .digest(MessageDigest::sha256())
+                        .unwrap()
+                        .iter()
+                        .map(|x| format!("{x:X}"))
+                        .join(":"),
+                )?;
+                let server_info = d.as_server_info();
+                account.hostname = server_info.as_hostname().de().map(Hostname)?;
+                account.server_id = server_info.as_id().de()?;
+
+                Ok(account)
+            })
+            .await?;
+        account.save(secrets).await?;
+        sync_hostname(&account.hostname).await?;
+
+        let parsed_url = Some(COMMUNITY_URL.parse().unwrap());
+        db.mutate(|d| {
+            let mut ui = d.as_ui().de()?;
+            use imbl_value::json;
+            ui["marketplace"]["known-hosts"][COMMUNITY_URL] = json!({});
+            ui["marketplace"]["known-hosts"][MAIN_REGISTRY] = json!({});
+            for package_id in d.as_package_data().keys()? {
+                if !COMMUNITY_SERVICES.contains(&&*package_id.to_string()) {
+                    continue;
+                }
+                d.as_package_data_mut()
+                    .as_idx_mut(&package_id)
+                    .or_not_found(&package_id)?
+                    .as_installed_mut()
+                    .or_not_found(&package_id)?
+                    .as_marketplace_url_mut()
+                    .ser(&parsed_url)?;
+            }
+            ui["theme"] = json!("Dark".to_string());
+            ui["widgets"] = json!([]);
+
+            d.as_ui_mut().ser(&ui)
+        })
+        .await
+    }
+    async fn down(&self, db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        db.mutate(|d| {
+            let mut ui = d.as_ui().de()?;
+            let parsed_url = Some(MAIN_REGISTRY.parse().unwrap());
+            for package_id in d.as_package_data().keys()? {
+                if !COMMUNITY_SERVICES.contains(&&*package_id.to_string()) {
+                    continue;
+                }
+                d.as_package_data_mut()
+                    .as_idx_mut(&package_id)
+                    .or_not_found(&package_id)?
+                    .as_installed_mut()
+                    .or_not_found(&package_id)?
+                    .as_marketplace_url_mut()
+                    .ser(&parsed_url)?;
+            }
+
+            if let imbl_value::Value::Object(ref mut obj) = ui {
+                obj.remove("theme");
+                obj.remove("widgets");
+            }
+
+            ui["marketplace"]["known-hosts"][COMMUNITY_URL].take();
+            ui["marketplace"]["known-hosts"][MAIN_REGISTRY].take();
+            d.as_ui_mut().ser(&ui)
+        })
+        .await
+    }
+}

core/startos/src/version/v0_3_4_1.rs

@@ -0,0 +1,31 @@
+use async_trait::async_trait;
+use emver::VersionRange;
+
+use super::v0_3_4::V0_3_0_COMPAT;
+use super::*;
+use crate::prelude::*;
+
+const V0_3_4_1: emver::Version = emver::Version::new(0, 3, 4, 1);
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = v0_3_4::Version;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_4_1
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &*V0_3_0_COMPAT
+    }
+    async fn up(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+    async fn down(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+}

core/startos/src/version/v0_3_4_2.rs

@@ -0,0 +1,31 @@
+use async_trait::async_trait;
+use emver::VersionRange;
+
+use super::v0_3_4::V0_3_0_COMPAT;
+use super::*;
+use crate::prelude::*;
+
+const V0_3_4_2: emver::Version = emver::Version::new(0, 3, 4, 2);
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = v0_3_4_1::Version;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_4_2
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &*V0_3_0_COMPAT
+    }
+    async fn up(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+    async fn down(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+}

core/startos/src/version/v0_3_4_3.rs

@@ -0,0 +1,31 @@
+use async_trait::async_trait;
+use emver::VersionRange;
+
+use super::v0_3_4::V0_3_0_COMPAT;
+use super::*;
+use crate::prelude::*;
+
+const V0_3_4_3: emver::Version = emver::Version::new(0, 3, 4, 3);
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = v0_3_4_2::Version;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_4_3
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &V0_3_0_COMPAT
+    }
+    async fn up(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+    async fn down(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+}

core/startos/src/version/v0_3_4_4.rs

@@ -0,0 +1,43 @@
+use async_trait::async_trait;
+use emver::VersionRange;
+use models::ResultExt;
+use sqlx::PgPool;
+
+use super::v0_3_4::V0_3_0_COMPAT;
+use super::{v0_3_4_3, VersionT};
+use crate::prelude::*;
+
+const V0_3_4_4: emver::Version = emver::Version::new(0, 3, 4, 4);
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = v0_3_4_3::Version;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_4_4
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &V0_3_0_COMPAT
+    }
+    async fn up(&self, db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        db.mutate(|v| {
+            let tor_address_lens = v.as_server_info_mut().as_tor_address_mut();
+            let mut tor_addr = tor_address_lens.de()?;
+            tor_addr
+                .set_scheme("https")
+                .map_err(|_| eyre!("unable to update url scheme to https"))
+                .with_kind(crate::ErrorKind::ParseUrl)?;
+            tor_address_lens.ser(&tor_addr)
+        })
+        .await?;
+        Ok(())
+    }
+    async fn down(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+}

core/startos/src/version/v0_3_5.rs

@@ -0,0 +1,109 @@
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use async_trait::async_trait;
+use emver::VersionRange;
+use models::DataUrl;
+use sqlx::PgPool;
+
+use super::v0_3_4::V0_3_0_COMPAT;
+use super::{v0_3_4_4, VersionT};
+use crate::prelude::*;
+
+const V0_3_5: emver::Version = emver::Version::new(0, 3, 5, 0);
+
+#[derive(Clone, Debug)]
+pub struct Version;
+
+#[async_trait]
+impl VersionT for Version {
+    type Previous = v0_3_4_4::Version;
+    fn new() -> Self {
+        Version
+    }
+    fn semver(&self) -> emver::Version {
+        V0_3_5
+    }
+    fn compat(&self) -> &'static VersionRange {
+        &V0_3_0_COMPAT
+    }
+    async fn up(&self, db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        let peek = db.peek().await;
+        let mut url_replacements = BTreeMap::new();
+        for (_, pde) in peek.as_package_data().as_entries()? {
+            for (dependency, info) in pde
+                .as_installed()
+                .map(|i| i.as_dependency_info().as_entries())
+                .transpose()?
+                .into_iter()
+                .flatten()
+            {
+                if !url_replacements.contains_key(&dependency) {
+                    url_replacements.insert(
+                        dependency,
+                        DataUrl::from_path(
+                            <&Value>::from(info.as_icon())
+                                .as_str()
+                                .and_then(|i| i.strip_prefix("/public/package-data/"))
+                                .map(|path| {
+                                    Path::new("/embassy-data/package-data/public").join(path)
+                                })
+                                .unwrap_or_default(),
+                        )
+                        .await
+                        .unwrap_or_else(|_| {
+                            DataUrl::from_slice(
+                                "image/png",
+                                include_bytes!("../install/package-icon.png"),
+                            )
+                        }),
+                    );
+                }
+            }
+        }
+        let prev_zram = db
+            .mutate(|v| {
+                for (_, pde) in v.as_package_data_mut().as_entries_mut()? {
+                    for (dependency, info) in pde
+                        .as_installed_mut()
+                        .map(|i| i.as_dependency_info_mut().as_entries_mut())
+                        .transpose()?
+                        .into_iter()
+                        .flatten()
+                    {
+                        if let Some(url) = url_replacements.get(&dependency) {
+                            info.as_icon_mut().ser(url)?;
+                        } else {
+                            info.as_icon_mut().ser(&DataUrl::from_slice(
+                                "image/png",
+                                include_bytes!("../install/package-icon.png"),
+                            ))?;
+                        }
+                        let manifest = <&mut Value>::from(&mut *info)
+                            .as_object_mut()
+                            .and_then(|o| o.remove("manifest"));
+                        if let Some(title) = manifest
+                            .as_ref()
+                            .and_then(|m| m.as_object())
+                            .and_then(|m| m.get("title"))
+                            .and_then(|t| t.as_str())
+                            .map(|s| s.to_owned())
+                        {
+                            info.as_title_mut().ser(&title)?;
+                        } else {
+                            info.as_title_mut().ser(&dependency.to_string())?;
+                        }
+                    }
+                }
+                v.as_server_info_mut().as_zram_mut().replace(&true)
+            })
+            .await?;
+        if !prev_zram {
+            crate::system::enable_zram().await?;
+        }
+        Ok(())
+    }
+    async fn down(&self, _db: PatchDb, _secrets: &PgPool) -> Result<(), Error> {
+        Ok(())
+    }
+}