|
|
@@ -1,12 +1,23 @@
|
|
|
use async_executor::Executor;
|
|
|
use async_std::sync::Arc;
|
|
|
+use async_trait::async_trait;
|
|
|
use futures_lite::future;
|
|
|
use log::{error, info};
|
|
|
+use serde_json::{json, Value};
|
|
|
+use std::collections::HashMap;
|
|
|
use structopt_toml::StructOptToml;
|
|
|
use url::Url;
|
|
|
|
|
|
use darkfi::{
|
|
|
async_daemonize, net,
|
|
|
+ net::P2pPtr,
|
|
|
+ rpc::{
|
|
|
+ jsonrpc::{
|
|
|
+ ErrorCode::{InvalidParams, MethodNotFound},
|
|
|
+ JsonError, JsonRequest, JsonResponse, JsonResult,
|
|
|
+ },
|
|
|
+ server::{listen_and_serve, RequestHandler},
|
|
|
+ },
|
|
|
util::{
|
|
|
cli::{get_log_config, get_log_level, spawn_config},
|
|
|
expand_path,
|
|
|
@@ -21,12 +32,69 @@ use config::{parse_configured_networks, Args, NetInfo};
|
|
|
const CONFIG_FILE: &str = "lilith_config.toml";
|
|
|
const CONFIG_FILE_CONTENTS: &str = include_str!("../lilith_config.toml");
|
|
|
|
|
|
+/// Struct representing a spawned p2p network.
|
|
|
+pub struct Spawn {
|
|
|
+ pub name: String,
|
|
|
+ pub p2p: P2pPtr,
|
|
|
+}
|
|
|
+
|
|
|
+impl Spawn {
|
|
|
+ async fn addresses(&self) -> Vec<String> {
|
|
|
+ self.p2p.hosts().load_all().await.iter().map(|addr| addr.to_string()).collect()
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// Struct representing the daemon.
|
|
|
+pub struct Lilith {
|
|
|
+ /// Spawned networks
|
|
|
+ spawns: Vec<Spawn>,
|
|
|
+}
|
|
|
+
|
|
|
+impl Lilith {
|
|
|
+ // RPCAPI:
|
|
|
+ // Returns all spawned networks names with their node addresses.
|
|
|
+ // --> {"jsonrpc": "2.0", "method": "spawns", "params": [], "id": 42}
|
|
|
+ // <-- {"jsonrpc": "2.0", "result": "{spawns}", "id": 42}
|
|
|
+ async fn spawns(&self, id: Value, _params: &[Value]) -> JsonResult {
|
|
|
+ let mut spawns: HashMap<String, Vec<String>> = HashMap::default();
|
|
|
+ for spawn in &self.spawns {
|
|
|
+ spawns.insert(spawn.name.clone(), spawn.addresses().await);
|
|
|
+ }
|
|
|
+ JsonResponse::new(json!(spawns), id).into()
|
|
|
+ }
|
|
|
+
|
|
|
+ // RPCAPI:
|
|
|
+ // Replies to a ping method.
|
|
|
+ // --> {"jsonrpc": "2.0", "method": "ping", "params": [], "id": 42}
|
|
|
+ // <-- {"jsonrpc": "2.0", "result": "pong", "id": 42}
|
|
|
+ async fn pong(&self, id: Value, _params: &[Value]) -> JsonResult {
|
|
|
+ JsonResponse::new(json!("pong"), id).into()
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[async_trait]
|
|
|
+impl RequestHandler for Lilith {
|
|
|
+ async fn handle_request(&self, req: JsonRequest) -> JsonResult {
|
|
|
+ if !req.params.is_array() {
|
|
|
+ return JsonError::new(InvalidParams, None, req.id).into()
|
|
|
+ }
|
|
|
+
|
|
|
+ let params = req.params.as_array().unwrap();
|
|
|
+
|
|
|
+ match req.method.as_str() {
|
|
|
+ Some("spawns") => return self.spawns(req.id, params).await,
|
|
|
+ Some("ping") => return self.pong(req.id, params).await,
|
|
|
+ Some(_) | None => return JsonError::new(MethodNotFound, None, req.id).into(),
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
async fn spawn_network(
|
|
|
name: &str,
|
|
|
info: NetInfo,
|
|
|
urls: Vec<Url>,
|
|
|
ex: Arc<Executor<'_>>,
|
|
|
-) -> Result<()> {
|
|
|
+) -> Result<Spawn> {
|
|
|
let mut full_urls = Vec::new();
|
|
|
for url in &urls {
|
|
|
let mut url = url.clone();
|
|
|
@@ -51,14 +119,17 @@ async fn spawn_network(
|
|
|
info!("Starting seed network node for {} at: {:?}", name, urls_vec);
|
|
|
p2p.clone().start(ex.clone()).await?;
|
|
|
let _ex = ex.clone();
|
|
|
+ let _p2p = p2p.clone();
|
|
|
ex.spawn(async move {
|
|
|
- if let Err(e) = p2p.run(_ex).await {
|
|
|
+ if let Err(e) = _p2p.run(_ex).await {
|
|
|
error!("Failed starting P2P network seed: {}", e);
|
|
|
}
|
|
|
})
|
|
|
.detach();
|
|
|
|
|
|
- Ok(())
|
|
|
+ let spawn = Spawn { name: name.to_string(), p2p };
|
|
|
+
|
|
|
+ Ok(spawn)
|
|
|
}
|
|
|
|
|
|
async_daemonize!(realmain);
|
|
|
@@ -92,12 +163,21 @@ async fn realmain(args: Args, ex: Arc<Executor<'_>>) -> Result<()> {
|
|
|
}
|
|
|
|
|
|
// Spawn configured networks
|
|
|
+ let mut spawns = vec![];
|
|
|
for (name, info) in &configured_nets {
|
|
|
- if let Err(e) = spawn_network(name, info.clone(), urls.clone(), ex.clone()).await {
|
|
|
- error!("Failed starting {} P2P network seed: {}", name, e);
|
|
|
+ match spawn_network(name, info.clone(), urls.clone(), ex.clone()).await {
|
|
|
+ Ok(spawn) => spawns.push(spawn),
|
|
|
+ Err(e) => error!("Failed starting {} P2P network seed: {}", name, e),
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+ let lilith = Lilith { spawns };
|
|
|
+ let lilith = Arc::new(lilith);
|
|
|
+
|
|
|
+ // JSON-RPC server
|
|
|
+ info!("Starting JSON-RPC server");
|
|
|
+ ex.spawn(listen_and_serve(args.rpc_listen, lilith)).detach();
|
|
|
+
|
|
|
// Wait for SIGINT
|
|
|
shutdown.recv().await?;
|
|
|
print!("\r");
|
aggstam