Rename distributed.sync configuration to replicas

Also adds the "one" and "majority" options.

Author: Thomasdezeeuw

Diff for: config.example.toml

@@ -16,9 +16,15 @@ address = "127.0.0.1:8080"
 [distributed]
 # Address to listen on for peer connections.
 peer_address = "127.0.0.1:9001"
-# Type of synchronisation of the blobs between nodes, available methods:
-# - `full': all nodes store all blobs (default).
-sync = "full"
+# The amount of replicas of the blob stored, available options:
+# - `all': all nodes store all blobs (default). Highest availability, lowest
+#   chance of data lost, but highest amount of storage used.
+# - `one': a single node stores a blob. Lowest availability, highest chance of
+#   data lost, but lowest amount of storage used.
+# - `majority': (N/2)+1 nodes store a blob, where N is the total number of nodes
+#   in the system. Medium availability, medium chance of data lost, medium
+#   amount of storage used.
+replicas = "all"
 # Addresses of peers to connect to.
 # Note that these don't need to contain all addresses, a single address of the
 # entire group is enough as each will automatically share all known peers.

Diff for: src/bin/server.rs

@@ -68,7 +68,7 @@ fn try_main() -> Result<(), ExitCode> {
             distributed_config.peer_address
         );
         info!("connecting to peers: {}", distributed_config.peers);
-        info!("synchronisation method: {}", distributed_config.sync);
+        info!("blob replication method: {}", distributed_config.replicas);
     }
 
     runtime

Diff for: src/config.rs

@@ -94,60 +94,69 @@ impl Default for Http {
 #[derive(Deserialize, Debug)]
 pub struct Distributed {
     pub peer_address: SocketAddr,
-    pub sync: Sync,
+    pub replicas: Replicas,
     pub peers: Peers,
 }
 
-/// Type of synchronisation of the blobs between nodes.
+/// The amount of replicas of the blob stored.
 #[derive(Copy, Clone, Debug)]
-pub enum Sync {
-    /// Full synchronisation: all nodes store all blobs (default).
-    Full,
+pub enum Replicas {
+    /// All nodes store all blobs (default).
+    All,
+    /// A single node stores a blob.
+    One,
+    /// `(N/2)+1` nodes store a blob, where `N` is the total number of nodes in
+    /// the system.
+    Majority,
 }
 
-impl Default for Sync {
-    fn default() -> Sync {
-        Sync::Full
+impl Default for Replicas {
+    fn default() -> Replicas {
+        Replicas::All
     }
 }
 
-impl fmt::Display for Sync {
+impl fmt::Display for Replicas {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Sync::Full => f.write_str("full"),
+            Replicas::All => f.write_str("all"),
+            Replicas::One => f.write_str("one"),
+            Replicas::Majority => f.write_str("majority"),
         }
     }
 }
 
-/// Error returned by `FromStr` implementation for [`Sync`].
-pub struct ParseSyncErr(());
+/// Error returned by `FromStr` implementation for [`Replicas`].
+pub struct ParseReplicasErr(());
 
-impl fmt::Display for ParseSyncErr {
+impl fmt::Display for ParseReplicasErr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("invalid synchronisation method")
+        f.write_str("invalid replicas")
     }
 }
 
-impl FromStr for Sync {
-    type Err = ParseSyncErr;
+impl FromStr for Replicas {
+    type Err = ParseReplicasErr;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "full" => Ok(Sync::Full),
-            _ => Err(ParseSyncErr(())),
+            "all" => Ok(Replicas::All),
+            "one" => Ok(Replicas::One),
+            "majority" => Ok(Replicas::Majority),
+            _ => Err(ParseReplicasErr(())),
         }
     }
 }
 
-impl<'de> Deserialize<'de> for Sync {
+impl<'de> Deserialize<'de> for Replicas {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
-        struct SyncVisitor;
+        struct ReplicasVisitor;
 
-        impl<'de> Visitor<'de> for SyncVisitor {
-            type Value = Sync;
+        impl<'de> Visitor<'de> for ReplicasVisitor {
+            type Value = Replicas;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                 formatter.write_str("a string")
@@ -157,11 +166,11 @@ impl<'de> Deserialize<'de> for Sync {
             where
                 E: Error,
             {
-                Sync::from_str(s).map_err(Error::custom)
+                Replicas::from_str(s).map_err(Error::custom)
             }
         }
 
-        deserializer.deserialize_str(SyncVisitor)
+        deserializer.deserialize_str(ReplicasVisitor)
     }
 }