feat: feature and experimental feature flags (#448)

* feat: feature and experimental feature flags

* chore: clippy

* fix: review

---------

Co-authored-by: Danny Browning <dbrowning@3box.io>

api/src/server.rs

@@ -323,6 +323,7 @@ pub struct Server<C, I, M> {
     // so we just keep track to gracefully shutdown, but if the task dies, the server is in a fatal error state.
     insert_task: Arc<InsertTask>,
     marker: PhantomData<C>,
+    authentication: bool,
 }
 
 impl<C, I, M> Server<C, I, M>
@@ -346,9 +347,15 @@ where
             model,
             insert_task,
             marker: PhantomData,
+            authentication: false,
         }
     }
 
+    pub fn with_authentication(&mut self, authentication: bool) -> &mut Self {
+        self.authentication = authentication;
+        self
+    }
+
     fn start_insert_task(
         event_store: Arc<M>,
         mut event_rx: tokio::sync::mpsc::Receiver<EventInsert>,

one/src/feature_flags.rs

@@ -0,0 +1,52 @@
+use anyhow::{anyhow, Result};
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum ExperimentalFeatureFlags {
+    None,
+    Authentication,
+}
+
+impl std::str::FromStr for ExperimentalFeatureFlags {
+    type Err = anyhow::Error;
+
+    fn from_str(value: &str) -> Result<Self> {
+        match value.to_ascii_lowercase().as_str() {
+            "none" => Ok(ExperimentalFeatureFlags::None),
+            "authentication" => Ok(ExperimentalFeatureFlags::Authentication),
+            _ => Err(anyhow!("invalid value")),
+        }
+    }
+}
+
+impl std::fmt::Display for ExperimentalFeatureFlags {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ExperimentalFeatureFlags::None => write!(f, "none"),
+            ExperimentalFeatureFlags::Authentication => write!(f, "authentication"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum FeatureFlags {
+    None,
+}
+
+impl std::fmt::Display for FeatureFlags {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FeatureFlags::None => write!(f, "none"),
+        }
+    }
+}
+
+impl std::str::FromStr for FeatureFlags {
+    type Err = anyhow::Error;
+
+    fn from_str(value: &str) -> Result<Self> {
+        match value.to_ascii_lowercase().as_str() {
+            "none" => Ok(FeatureFlags::None),
+            _ => Err(anyhow!("invalid value")),
+        }
+    }
+}

one/src/lib.rs

@@ -1,6 +1,7 @@
 //! Ceramic implements a single binary ceramic node.
 #![warn(missing_docs)]
 
+mod feature_flags;
 mod http;
 mod http_metrics;
 mod metrics;
@@ -17,6 +18,7 @@ use ceramic_metrics::{config::Config as MetricsConfig, MetricsHandle};
 use ceramic_p2p::{load_identity, DiskStorage, Keychain, Libp2pConfig};
 use ceramic_service::{CeramicEventService, CeramicInterestService, CeramicService};
 use clap::{Args, Parser, Subcommand, ValueEnum};
+use feature_flags::*;
 use futures::StreamExt;
 use multibase::Base;
 use multihash::Multihash;
@@ -42,7 +44,7 @@ struct Cli {
 #[derive(Subcommand, Debug)]
 enum Command {
     /// Run a daemon process
-    Daemon(DaemonOpts),
+    Daemon(Box<DaemonOpts>),
     /// Perform various migrations
     #[command(subcommand)]
     Migrations(migrations::EventsCommand),
@@ -167,6 +169,24 @@ struct DaemonOpts {
             env = "CERAMIC_ONE_CORS_ALLOW_ORIGINS"
         )]
     cors_allow_origins: Vec<String>,
+
+    /// Enable experimental feature flags
+    #[arg(
+        long,
+        use_value_delimiter = true,
+        value_delimiter = ',',
+        env = "CERAMIC_ONE_EXPERIMENTAL_FEATURE_FLAGS"
+    )]
+    experimental_feature_flags: Vec<ExperimentalFeatureFlags>,
+
+    /// Enable feature flags
+    #[arg(
+        long,
+        use_value_delimiter = true,
+        value_delimiter = ',',
+        env = "CERAMIC_ONE_FEATURE_FLAGS"
+    )]
+    feature_flags: Vec<FeatureFlags>,
 }
 
 #[derive(Args, Debug)]
@@ -264,7 +284,7 @@ impl Network {
 pub async fn run() -> Result<()> {
     let args = Cli::parse();
     match args.command {
-        Command::Daemon(opts) => Daemon::run(opts).await,
+        Command::Daemon(opts) => Daemon::run(*opts).await,
         Command::Migrations(opts) => migrations::migrate(opts).await,
     }
 }
@@ -534,12 +554,18 @@ impl Daemon {
             })?;
 
         // Build HTTP server
-        let ceramic_server = ceramic_api::Server::new(
+        let mut ceramic_server = ceramic_api::Server::new(
             peer_id,
             network,
             interest_api_store,
             Arc::new(model_api_store),
         );
+        if opts
+            .experimental_feature_flags
+            .contains(&ExperimentalFeatureFlags::Authentication)
+        {
+            ceramic_server.with_authentication(true);
+        }
         let ceramic_service = ceramic_api_server::server::MakeService::new(ceramic_server);
         let ceramic_service = MakeAllowAllAuthenticator::new(ceramic_service, "");
         let ceramic_service =