support extensions

Author: imabdulbasit

Cargo.lock

@@ -17,7 +17,7 @@ cld = "0.5"
 espresso-types = { git = "https://github.com/EspressoSystems/espresso-sequencer.git", branch = "main", features = [ "testing" ] }
 futures = "0.3"
 hotshot = { git = "https://github.com/EspressoSystems/HotShot.git", tag = "rc-0.5.61" }
-hotshot-events-service = { git = "https://github.com/EspressoSystems/hotshot-events-service.git", branch = "ab/remove-builder-event-types" }
+hotshot-events-service = { git = "https://github.com/EspressoSystems/hotshot-events-service.git", branch = "main" }
 hotshot-types = { git = "https://github.com/EspressoSystems/HotShot.git", tag = "rc-0.5.61" }
 serde = { version = "1.0", features = ["derive"] }
 snafu = "0.8"

Cargo.toml

@@ -1,3 +1,8 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
 use futures::FutureExt;
 use serde::{Deserialize, Serialize};
 use snafu::Snafu;
@@ -6,6 +11,7 @@ use tide_disco::{
     method::{ReadState, WriteState},
     Api, StatusCode,
 };
+use toml::{map::Entry, Value};
 use vbs::version::StaticVersionType;
 
 use crate::state::UpdateSolverState;
@@ -27,18 +33,38 @@ impl tide_disco::Error for SolverError {
     }
 }
 
-pub fn define_api<State, SolverError, VERSION>(
+pub struct ApiOptions {
+    pub api_path: Option<PathBuf>,
+
+    /// Additional API specification files to merge with `availability-api-path`.
+    ///
+    /// These optional files may contain route definitions for application-specific routes that have
+    /// been added as extensions to the basic availability API.
+    pub extensions: Vec<toml::Value>,
+}
+
+impl Default for ApiOptions {
+    fn default() -> Self {
+        Self {
+            api_path: None,
+            extensions: vec![],
+        }
+    }
+}
+
+pub fn define_api<State, VERSION>(
+    options: ApiOptions,
 ) -> Result<Api<State, SolverError, VERSION>, ApiError>
 where
     VERSION: StaticVersionType + 'static,
     State: 'static + Send + Sync + ReadState + WriteState,
     <State as ReadState>::State: Send + Sync + UpdateSolverState,
-    SolverError: 'static,
 {
-    let api_toml = toml::from_str::<toml::Value>(include_str!("../api/solver.toml"))
-        .expect("API file is not valid toml");
-
-    let mut api = Api::new(api_toml)?;
+    let mut api = load_api::<State, SolverError, VERSION>(
+        options.api_path.as_ref(),
+        include_str!("../api/solver.toml"),
+        options.extensions.clone(),
+    )?;
 
     // TODO ED: We need to fill these in with the appropriate logic later
     api.post("submit_bid", |_req, _state| {
@@ -61,3 +87,45 @@ where
     })?;
     Ok(api)
 }
+
+pub(crate) fn load_api<State: 'static, Error: 'static, Ver: StaticVersionType + 'static>(
+    path: Option<impl AsRef<Path>>,
+    default: &str,
+    extensions: impl IntoIterator<Item = Value>,
+) -> Result<Api<State, Error, Ver>, ApiError> {
+    let mut toml = match path {
+        Some(path) => load_toml(path.as_ref())?,
+        None => toml::from_str(default).map_err(|err| ApiError::CannotReadToml {
+            reason: err.to_string(),
+        })?,
+    };
+    for extension in extensions {
+        merge_toml(&mut toml, extension);
+    }
+    Api::new(toml)
+}
+
+fn merge_toml(into: &mut Value, from: Value) {
+    if let (Value::Table(into), Value::Table(from)) = (into, from) {
+        for (key, value) in from {
+            match into.entry(key) {
+                Entry::Occupied(mut entry) => merge_toml(entry.get_mut(), value),
+                Entry::Vacant(entry) => {
+                    entry.insert(value);
+                }
+            }
+        }
+    }
+}
+
+fn load_toml(path: &Path) -> Result<Value, ApiError> {
+    let bytes = fs::read(path).map_err(|err| ApiError::CannotReadToml {
+        reason: err.to_string(),
+    })?;
+    let string = std::str::from_utf8(&bytes).map_err(|err| ApiError::CannotReadToml {
+        reason: err.to_string(),
+    })?;
+    toml::from_str(string).map_err(|err| ApiError::CannotReadToml {
+        reason: err.to_string(),
+    })
+}

src/api.rs

@@ -17,7 +17,7 @@ pub async fn main() {
     let mut app = App::<_, SolverError>::with_state(RwLock::new(GlobalState::mock()));
     app.with_version(env!("CARGO_PKG_VERSION").parse().unwrap());
 
-    let mut api = define_api()
+    let mut api = define_api(Default::default())
         .map_err(|_e| io::Error::new(ErrorKind::Other, "Failed to define api"))
         .unwrap();
     api.with_version(env!("CARGO_PKG_VERSION").parse().unwrap());

src/main.rs

@@ -8,10 +8,13 @@ use tide_disco::Url;
 pub struct Options {
     #[clap(long, env = "HOTSHOT_EVENTS_API_URL")]
     pub events_url: Url,
+
+    #[clap(flatten)]
+    pub database_options: DatabaseOptions,
 }
 
 /// Arguments for establishing a database connection
-#[derive(Debug, Parser)]
+#[derive(Clone, Debug, Parser)]
 pub struct DatabaseOptions {
     #[clap(long, env = "MARKETPLACE_SOLVER_DATABASE_URL")]
     pub url: String,