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/db/model.rs

@@ -13,30 +13,46 @@ use patch_db::json_ptr::JsonPointer;
 use patch_db::{HasModel, Value};
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
-use ssh_key::public::Ed25519PublicKey;
+use torut::onion::OnionAddressV3;
 
 use crate::account::AccountInfo;
+use crate::auth::Sessions;
+use crate::backup::target::cifs::CifsTargets;
+use crate::net::forward::AvailablePorts;
+use crate::net::host::HostInfo;
+use crate::net::keys::KeyStore;
 use crate::net::utils::{get_iface_ipv4_addr, get_iface_ipv6_addr};
+use crate::notifications::Notifications;
 use crate::prelude::*;
 use crate::progress::FullProgress;
 use crate::s9pk::manifest::Manifest;
+use crate::ssh::SshKeys;
 use crate::status::Status;
 use crate::util::cpupower::Governor;
+use crate::util::serde::Pem;
 use crate::util::Version;
 use crate::version::{Current, VersionT};
 use crate::{ARCH, PLATFORM};
 
+fn get_arch() -> InternedString {
+    (*ARCH).into()
+}
+
+fn get_platform() -> InternedString {
+    (&*PLATFORM).into()
+}
+
 #[derive(Debug, Deserialize, Serialize, HasModel)]
 #[serde(rename_all = "kebab-case")]
 #[model = "Model<Self>"]
 pub struct Database {
     pub public: Public,
-    pub private: (), // TODO
+    pub private: Private,
 }
 impl Database {
-    pub fn init(account: &AccountInfo) -> Self {
+    pub fn init(account: &AccountInfo) -> Result<Self, Error> {
         let lan_address = account.hostname.lan_address().parse().unwrap();
-        Database {
+        Ok(Database {
             public: Public {
                 server_info: ServerInfo {
                     arch: get_arch(),
@@ -48,9 +64,13 @@ impl Database {
                     last_wifi_region: None,
                     eos_version_compat: Current::new().compat().clone(),
                     lan_address,
-                    tor_address: format!("https://{}", account.key.tor_address())
-                        .parse()
-                        .unwrap(),
+                    onion_address: account.tor_key.public().get_onion_address(),
+                    tor_address: format!(
+                        "https://{}",
+                        account.tor_key.public().get_onion_address()
+                    )
+                    .parse()
+                    .unwrap(),
                     ip_info: BTreeMap::new(),
                     status_info: ServerStatus {
                         backup_progress: None,
@@ -70,11 +90,9 @@ impl Database {
                         clearnet: Vec::new(),
                     },
                     password_hash: account.password.clone(),
-                    pubkey: ssh_key::PublicKey::from(Ed25519PublicKey::from(
-                        &account.key.ssh_key(),
-                    ))
-                    .to_openssh()
-                    .unwrap(),
+                    pubkey: ssh_key::PublicKey::from(&account.ssh_key)
+                        .to_openssh()
+                        .unwrap(),
                     ca_fingerprint: account
                         .root_ca_cert
                         .digest(MessageDigest::sha256())
@@ -93,11 +111,22 @@ impl Database {
                 )))
                 .unwrap(),
             },
-            private: (), // TODO
-        }
+            private: Private {
+                key_store: KeyStore::new(account)?,
+                password: account.password.clone(),
+                ssh_privkey: Pem(account.ssh_key.clone()),
+                ssh_pubkeys: SshKeys::new(),
+                available_ports: AvailablePorts::new(),
+                sessions: Sessions::new(),
+                notifications: Notifications::new(),
+                cifs: CifsTargets::new(),
+            }, // TODO
+        })
     }
 }
 
+pub type DatabaseModel = Model<Database>;
+
 #[derive(Debug, Deserialize, Serialize, HasModel)]
 #[serde(rename_all = "kebab-case")]
 #[model = "Model<Self>"]
@@ -108,14 +137,18 @@ pub struct Public {
     pub ui: Value,
 }
 
-pub type DatabaseModel = Model<Database>;
-
-fn get_arch() -> InternedString {
-    (*ARCH).into()
-}
-
-fn get_platform() -> InternedString {
-    (&*PLATFORM).into()
+#[derive(Debug, Deserialize, Serialize, HasModel)]
+#[serde(rename_all = "kebab-case")]
+#[model = "Model<Self>"]
+pub struct Private {
+    pub key_store: KeyStore,
+    pub password: String, // argon2 hash
+    pub ssh_privkey: Pem<ssh_key::PrivateKey>,
+    pub ssh_pubkeys: SshKeys,
+    pub available_ports: AvailablePorts,
+    pub sessions: Sessions,
+    pub notifications: Notifications,
+    pub cifs: CifsTargets,
 }
 
 #[derive(Debug, Deserialize, Serialize, HasModel)]
@@ -134,6 +167,8 @@ pub struct ServerInfo {
     pub last_wifi_region: Option<CountryCode>,
     pub eos_version_compat: VersionRange,
     pub lan_address: Url,
+    pub onion_address: OnionAddressV3,
+    /// for backwards compatibility
     pub tor_address: Url,
     pub ip_info: BTreeMap<String, IpInfo>,
     #[serde(default)]
@@ -229,6 +264,12 @@ pub struct AllPackageData(pub BTreeMap<PackageId, PackageDataEntry>);
 impl Map for AllPackageData {
     type Key = PackageId;
     type Value = PackageDataEntry;
+    fn key_str(key: &Self::Key) -> Result<impl AsRef<str>, Error> {
+        Ok(key)
+    }
+    fn key_string(key: &Self::Key) -> Result<InternedString, Error> {
+        Ok(key.clone().into())
+    }
 }
 
 #[derive(Debug, Deserialize, Serialize, HasModel)]
@@ -471,6 +512,7 @@ pub struct InstalledPackageInfo {
     pub current_dependents: CurrentDependents,
     pub current_dependencies: CurrentDependencies,
     pub interface_addresses: InterfaceAddressMap,
+    pub hosts: HostInfo,
     pub store: Value,
     pub store_exposed_ui: Vec<ExposedUI>,
     pub store_exposed_dependents: Vec<JsonPointer>,
@@ -512,6 +554,12 @@ impl CurrentDependents {
 impl Map for CurrentDependents {
     type Key = PackageId;
     type Value = CurrentDependencyInfo;
+    fn key_str(key: &Self::Key) -> Result<impl AsRef<str>, Error> {
+        Ok(key)
+    }
+    fn key_string(key: &Self::Key) -> Result<InternedString, Error> {
+        Ok(key.clone().into())
+    }
 }
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct CurrentDependencies(pub BTreeMap<PackageId, CurrentDependencyInfo>);
@@ -529,6 +577,12 @@ impl CurrentDependencies {
 impl Map for CurrentDependencies {
     type Key = PackageId;
     type Value = CurrentDependencyInfo;
+    fn key_str(key: &Self::Key) -> Result<impl AsRef<str>, Error> {
+        Ok(key)
+    }
+    fn key_string(key: &Self::Key) -> Result<InternedString, Error> {
+        Ok(key.clone().into())
+    }
 }
 
 #[derive(Debug, Deserialize, Serialize, HasModel)]
@@ -552,6 +606,12 @@ pub struct InterfaceAddressMap(pub BTreeMap<HostId, InterfaceAddresses>);
 impl Map for InterfaceAddressMap {
     type Key = HostId;
     type Value = InterfaceAddresses;
+    fn key_str(key: &Self::Key) -> Result<impl AsRef<str>, Error> {
+        Ok(key)
+    }
+    fn key_string(key: &Self::Key) -> Result<InternedString, Error> {
+        Ok(key.clone().into())
+    }
 }
 
 #[derive(Debug, Deserialize, Serialize, HasModel)]