wip: macro to ease Data boilerplate

Author: cilki

README.md

@@ -8,8 +8,8 @@
 
 <hr>
 
-`sandpolis` is a **virtual estate monitoring/management tool** (VEM²) under
-active development.
+`sandpolis` is a **virtual estate manager** (VEM) for people with too many
+computers.
 
 <p align="center">
 	<img src="https://raw.githubusercontent.com/fossable/sandpolis/master/.github/images/overview.png" />
@@ -42,14 +42,40 @@ attack surface that includes both `Machine A` and `Machine B`. If `Machine A`
 happens to have a weak password or one that's shared with another website, then
 the attack surface is consequently expanded with appropriate probabilities.
 
-Mapping these relationships automatically is possible because Sandpolis runs an
-agent on `Machine A` and `Machine B`.
+### Why sovereignty over your virtual estate is important
+
+With virtual estates, it's not always clear who is in control of what and
+exactly how much control they have.
+
+Control is usually divided among multiple parties. For example, control of your
+Github repos is shared between you and Github Inc (and probably Microsoft too).
+Control of your physical iPhone is shared between you and Apple (with Apple
+argubly having the majority). Control of your password manager is hopefully not
+shared with anyone.
+
+While it's impossible to know exactly what percentage of control we have over
+our virtual estates, it definitely seems to be trending down. People are willing
+to give up control for features and convenience, and they didn't seem to notice
+the tradeoff.
+
+If we don't prioritize control of our virtual estates, we might eventually lose
+it altogether. Imagine an alternate reality where all we have are thin clients!
+
+Sandpolis is a tool designed to help realize as much sovereignty over your
+virtual estate as possible. It provides total control over the devices you own
+(via a local agent process) and visualizes how those devices interact with parts
+of your virtual estate that you don't directly own (such as cloud services).
+
+There's no going back to the level of computing sovereignty we had before the
+Internet, but we don't want the opposite extreme either. We want a healthy
+medium of _partial sovereignty_ where people are aware and accepting of the
+control tradeoffs they are making.
 
 ## Security Warning
 
-Sandpolis is an extremely high-value attack target as it provides management
-capabilities on your virtual estate. To compensate, strong security measures are
-available:
+The Sandpolis server is an extremely high-value attack target as it provides
+management capabilities over your virtual estate. To compensate, strong security
+measures are available:
 
 - All connections to a server use mTLS and require a valid client certificate.
   The server automatically rotates these certificates periodically, but the
@@ -60,16 +86,21 @@ available:
 - User permissions restrict what users are able to do and on what instances.
 
 Even with several layers of strong authentication, there's always risk that the
-Sandpolis server can be compromised. If the risks of introducing a "single point
-of compromise" outweigh the convenience of having a unified management
-interface, then **don't use Sandpolis**.
+server can be compromised. If the risks of introducing a _single point of
+compromise_ outweigh the convenience of having a unified management interface,
+then **you don't have to use Sandpolis**.
 
 You can choose how much trust you allocate to the Sandpolis network. For
 example, agents can optionally run in _read only_ mode which still provides
 useful monitoring information, but prohibits all write operations (including
 agent updates). This can significantly mitigate potential damage in the event of
 server compromise.
 
+## How it works
+
+Sandpolis runs an agent on your devices and allows you to interact with them
+from a client application.
+
 ## Layers
 
 Features are organized into _layers_ that can be toggled on/off in the UI. If

sandpolis-account/README.md

@@ -3,3 +3,5 @@
 ### Attack surface map
 
 ### Compromise tracing
+
+### Control mapping

sandpolis-core/src/lib.rs

@@ -295,3 +295,41 @@ mod test_realm_name {
         );
     }
 }
+
+/// A user's username is forever unchangable.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct UserName(String);
+
+impl Deref for UserName {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl FromStr for UserName {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let name = UserName(s.to_string());
+        name.validate()?;
+        Ok(name)
+    }
+}
+
+impl Validate for UserName {
+    fn validate(&self) -> Result<(), ValidationErrors> {
+        if Regex::new("^[a-z0-9]{4,32}$").unwrap().is_match(&self.0) {
+            Ok(())
+        } else {
+            Err(ValidationErrors::new())
+        }
+    }
+}
+
+impl Default for UserName {
+    fn default() -> Self {
+        UserName("admin".to_string())
+    }
+}

sandpolis-database/src/lib.rs

@@ -90,10 +90,10 @@ impl DatabaseLayer {
 /// `Data` is what's stored in a database!
 pub trait Data
 where
-    Self: ToInput + Clone + PartialEq + Send + Sync,
+    Self: ToInput + Clone + PartialEq + Send + Sync + Default,
 {
     fn id(&self) -> DataIdentifier;
-    fn set_id(&mut self, id: DataIdentifier);
+    // fn set_id(&mut self, id: DataIdentifier);
 }
 
 /// `Data` that maintains a history of its value over time.
@@ -102,7 +102,7 @@ where
     Self: Data,
 {
     fn timestamp(&self) -> DbTimestamp;
-    fn set_timestamp(&self, timestamp: DbTimestamp);
+    // fn set_timestamp(&self, timestamp: DbTimestamp);
 
     fn timestamp_key() -> KeyDefinition<KeyOptions> {
         KeyDefinition::new(
@@ -194,7 +194,7 @@ impl<T: Data> Drop for Resident<T> {
     }
 }
 
-impl<T: Data + Default + 'static> Resident<T> {
+impl<T: Data + 'static> Resident<T> {
     /// Create a new `Watch` when there's only one row in the database.
     pub fn singleton(db: Arc<native_db::Database<'static>>) -> Result<Self> {
         let r = db.r_transaction()?;
@@ -298,16 +298,17 @@ impl<T: HistoricalData> Resident<T> {
         let r = self.db.r_transaction()?;
 
         // TODO use the most restrictive condition first for performance
-        let mut it = r.scan().secondary(T::timestamp_key())?.range(range)?;
+        // let mut it = r.scan().secondary(T::timestamp_key())?.range(range)?;
 
-        for (key_def, key) in secondary_keys.into_iter() {
-            it = it.and(r.scan().secondary(key_def)?.equal(match key {
-                KeyEntry::Default(key) => key,
-                KeyEntry::Optional(key) => key.unwrap(), // TODO
-            })?);
-        }
+        // for (key_def, key) in secondary_keys.into_iter() {
+        //     it = it.and(r.scan().secondary(key_def)?.equal(match key {
+        //         KeyEntry::Default(key) => key,
+        //         KeyEntry::Optional(key) => key.unwrap(), // TODO
+        //     })?);
+        // }
 
-        Ok(it.try_collect()?)
+        // Ok(it.try_collect()?)
+        todo!()
     }
 }
 
@@ -318,33 +319,20 @@ mod test_resident {
     use native_db::Models;
     use native_db::*;
     use native_model::{Model, native_model};
-    use sandpolis_macros::{Data, HistoricalData};
+    use sandpolis_macros::{Data, HistoricalData, data};
     use serde::{Deserialize, Serialize};
     use tokio::time::{Duration, sleep};
 
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Default, Data)]
-    #[native_model(id = 5, version = 1)]
-    #[native_db]
+    #[data]
     pub struct TestData {
-        #[primary_key]
-        pub _id: DataIdentifier,
-
         #[secondary_key]
         pub a: String,
         #[secondary_key]
         pub b: String,
     }
 
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Default, Data, HistoricalData)]
-    #[native_model(id = 6, version = 1)]
-    #[native_db]
+    #[data(history)]
     pub struct TestHistoryData {
-        #[primary_key]
-        pub _id: DataIdentifier,
-
-        #[secondary_key]
-        pub _timestamp: DbTimestamp,
-
         #[secondary_key]
         pub a: String,
         pub b: String,

sandpolis-instance/src/lib.rs

@@ -1,39 +1,22 @@
 use anyhow::Result;
 use clap::Parser;
 use native_db::ToKey;
-use native_db::*;
-use native_model::{Model, native_model};
+use native_model::Model;
 use sandpolis_core::{ClusterId, InstanceId};
 use sandpolis_database::{Data, DataIdentifier, DatabaseLayer, Resident};
-use sandpolis_macros::Data;
+use sandpolis_macros::data;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use std::{cmp::Ordering, ops::Deref};
 
 pub mod cli;
 
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Data)]
-#[native_model(id = 15, version = 1)]
-#[native_db]
+#[data]
 pub struct InstanceLayerData {
-    #[primary_key]
-    pub _id: DataIdentifier,
-
     pub cluster_id: ClusterId,
     pub instance_id: InstanceId,
     pub os_info: os_info::Info,
 }
 
-impl Default for InstanceLayerData {
-    fn default() -> Self {
-        Self {
-            _id: DataIdentifier::default(),
-            cluster_id: ClusterId::default(),
-            instance_id: InstanceId::default(),
-            os_info: os_info::get(),
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct InstanceLayer {
     data: Resident<InstanceLayerData>,