Feature/remove postgres (#2570)

* wip: move postgres data to patchdb

* wip

* wip

* wip

* complete notifications and clean up warnings

* fill in user agent

* move os tor bindings to single call

core/startos/src/version/mod.rs

@@ -1,33 +1,25 @@
 use std::cmp::Ordering;
 
-use async_trait::async_trait;
 use color_eyre::eyre::eyre;
+use futures::Future;
 use imbl_value::InternedString;
-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;
 mod v0_3_5_1;
+mod v0_3_6;
 
-pub type Current = v0_3_5_1::Version;
+pub type Current = v0_3_6::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>),
+    LT0_3_5(LTWrapper<v0_3_5::Version>),
     V0_3_5(Wrapper<v0_3_5::Version>),
     V0_3_5_1(Wrapper<v0_3_5_1::Version>),
+    V0_3_6(Wrapper<v0_3_6::Version>),
     Other(emver::Version),
 }
 
@@ -43,19 +35,15 @@ impl 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::LT0_3_5(LTWrapper(_, x)) => x.clone(),
             Version::V0_3_5(Wrapper(x)) => x.semver(),
             Version::V0_3_5_1(Wrapper(x)) => x.semver(),
+            Version::V0_3_6(Wrapper(x)) => x.semver(),
             Version::Other(x) => x.clone(),
         }
     }
 }
 
-#[async_trait]
 pub trait VersionT
 where
     Self: Sized + Send + Sync,
@@ -64,86 +52,115 @@ where
     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_public_mut()
-                .as_server_info_mut()
-                .as_version_mut()
-                .ser(&semver)?;
-            d.as_public_mut()
-                .as_server_info_mut()
-                .as_eos_version_compat_mut()
-                .ser(&compat)?;
+    fn up(&self, db: &PatchDb) -> impl Future<Output = Result<(), Error>> + Send;
+    fn down(&self, db: &PatchDb) -> impl Future<Output = Result<(), Error>> + Send;
+    fn commit(&self, db: &PatchDb) -> impl Future<Output = Result<(), Error>> + Send {
+        async {
+            let semver = self.semver().into();
+            let compat = self.compat().clone();
+            db.mutate(|d| {
+                d.as_public_mut()
+                    .as_server_info_mut()
+                    .as_version_mut()
+                    .ser(&semver)?;
+                d.as_public_mut()
+                    .as_server_info_mut()
+                    .as_eos_version_compat_mut()
+                    .ser(&compat)?;
+                Ok(())
+            })
+            .await?;
             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>(
+    fn migrate_to<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,
-            ));
+        db: &PatchDb,
+    ) -> impl Future<Output = Result<(), Error>> + Send {
+        async {
+            match self.semver().cmp(&version.semver()) {
+                Ordering::Greater => self.rollback_to_unchecked(version, db).await,
+                Ordering::Less => version.migrate_from_unchecked(self, db).await,
+                Ordering::Equal => Ok(()),
+            }
         }
-        tracing::info!("{} -> {}", previous.semver(), self.semver(),);
-        self.up(db.clone(), secrets).await?;
-        self.commit(db).await?;
-        Ok(())
     }
-    async fn rollback_to_unchecked<V: VersionT>(
+    fn migrate_from_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,
-            ));
+        db: &PatchDb,
+    ) -> impl Future<Output = Result<(), Error>> + Send {
+        async {
+            let previous = Self::Previous::new();
+            if version.semver() < previous.semver() {
+                previous.migrate_from_unchecked(version, db).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).await?;
+            self.commit(db).await?;
+            Ok(())
+        }
+    }
+    fn rollback_to_unchecked<V: VersionT>(
+        &self,
+        version: &V,
+        db: &PatchDb,
+    ) -> impl Future<Output = Result<(), Error>> + Send {
+        async {
+            let previous = Self::Previous::new();
+            tracing::info!("{} -> {}", self.semver(), previous.semver(),);
+            self.down(db).await?;
+            previous.commit(db).await?;
+            if version.semver() < previous.semver() {
+                previous.rollback_to_unchecked(version, db).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(())
         }
-        Ok(())
     }
 }
+
+#[derive(Debug, Clone)]
+struct LTWrapper<T>(T, emver::Version);
+impl<T> serde::Serialize for LTWrapper<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 LTWrapper<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(Self(version, v.into_version()))
+        } else {
+            Err(serde::de::Error::custom("Mismatched Version"))
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 struct Wrapper<T>(T);
 impl<T> serde::Serialize for Wrapper<T>
@@ -169,7 +186,7 @@ where
     }
 }
 
-pub async fn init(db: &PatchDb, secrets: &PgPool) -> Result<(), Error> {
+pub async fn init(db: &PatchDb) -> Result<(), Error> {
     let version = Version::from_util_version(
         db.peek()
             .await
@@ -180,13 +197,15 @@ pub async fn init(db: &PatchDb, secrets: &PgPool) -> Result<(), Error> {
     );
 
     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::V0_3_5_1(v) => v.0.migrate_to(&Current::new(), db.clone(), secrets).await?,
+        Version::LT0_3_5(_) => {
+            return Err(Error::new(
+                eyre!("Cannot migrate from pre-0.3.5. Please update to v0.3.5 first."),
+                ErrorKind::MigrationFailed,
+            ));
+        }
+        Version::V0_3_5(v) => v.0.migrate_to(&Current::new(), &db).await?,
+        Version::V0_3_5_1(v) => v.0.migrate_to(&Current::new(), &db).await?,
+        Version::V0_3_6(v) => v.0.migrate_to(&Current::new(), &db).await?,
         Version::Other(_) => {
             return Err(Error::new(
                 eyre!("Cannot downgrade"),
@@ -218,11 +237,6 @@ mod tests {
 
     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()))),
-            Just(Version::V0_3_4_4(Wrapper(v0_3_4_4::Version::new()))),
             Just(Version::V0_3_5(Wrapper(v0_3_5::Version::new()))),
             Just(Version::V0_3_5_1(Wrapper(v0_3_5_1::Version::new()))),
             em_version().prop_map(Version::Other),