1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
mod shared;
use std::sync::Arc;
use clap::Parser;
use log::error;
use smol::{channel, Executor};
use karyon_p2p::{
endpoint::{Endpoint, Port},
keypair::{KeyPair, KeyPairType},
ArcBackend, Backend, Config,
};
use karyon_jsonrpc::{rpc_impl, rpc_pubsub_impl, ArcChannel, Server, SubscriptionID};
use shared::run_executor;
#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
/// Optional list of bootstrap peers to start the seeding process.
#[arg(short)]
bootstrap_peers: Vec<Endpoint>,
/// RPC server endpoint.
#[arg(short)]
rpc_endpoint: Endpoint,
/// Optional list of peer endpoints for manual connections.
#[arg(short)]
peer_endpoints: Vec<Endpoint>,
/// Optional endpoint for accepting incoming connections.
#[arg(short)]
listen_endpoint: Option<Endpoint>,
/// Optional TCP/UDP port for the discovery service.
#[arg(short)]
discovery_port: Option<Port>,
}
struct MonitorRPC {
backend: ArcBackend,
}
#[rpc_impl]
impl MonitorRPC {
async fn peer_id(
&self,
_params: serde_json::Value,
) -> Result<serde_json::Value, karyon_jsonrpc::Error> {
Ok(serde_json::json!(self.backend.peer_id().to_string()))
}
async fn inbound_connection(
&self,
_params: serde_json::Value,
) -> Result<serde_json::Value, karyon_jsonrpc::Error> {
Ok(serde_json::json!(self.backend.inbound_slots()))
}
async fn outbound_connection(
&self,
_params: serde_json::Value,
) -> Result<serde_json::Value, karyon_jsonrpc::Error> {
Ok(serde_json::json!(self.backend.inbound_slots()))
}
}
#[rpc_pubsub_impl]
impl MonitorRPC {
async fn conn_subscribe(
&self,
chan: ArcChannel,
method: String,
_params: serde_json::Value,
) -> Result<serde_json::Value, karyon_jsonrpc::Error> {
let sub = chan.new_subscription(&method).await;
let sub_id = sub.id.clone();
let conn_events = self.backend.monitor().conn_events().await;
smol::spawn(async move {
loop {
let _event = conn_events.recv().await;
if let Err(err) = sub.notify(serde_json::json!("event")).await {
error!("Failed to notify: {err}");
break;
}
}
})
.detach();
Ok(serde_json::json!(sub_id))
}
async fn conn_unsubscribe(
&self,
chan: ArcChannel,
_method: String,
params: serde_json::Value,
) -> Result<serde_json::Value, karyon_jsonrpc::Error> {
let sub_id: SubscriptionID = serde_json::from_value(params)?;
chan.remove_subscription(&sub_id).await;
Ok(serde_json::json!(true))
}
}
fn main() {
env_logger::init();
let cli = Cli::parse();
let key_pair = KeyPair::generate(&KeyPairType::Ed25519);
// Create the configuration for the backend.
let config = Config {
listen_endpoint: cli.listen_endpoint,
peer_endpoints: cli.peer_endpoints,
bootstrap_peers: cli.bootstrap_peers,
discovery_port: cli.discovery_port.unwrap_or(0),
enable_monitor: true,
..Default::default()
};
// Create a new Executor
let ex = Arc::new(Executor::new());
// Create a new Backend
let backend = Backend::new(&key_pair, config, ex.clone().into());
let (ctrlc_s, ctrlc_r) = channel::unbounded();
let handle = move || ctrlc_s.try_send(()).unwrap();
ctrlc::set_handler(handle).unwrap();
let exc = ex.clone();
run_executor(
async {
// RPC service
let service = Arc::new(MonitorRPC {
backend: backend.clone(),
});
// Create rpc server
let server = Server::builder(cli.rpc_endpoint)
.expect("Create server builder")
.service(service.clone())
.pubsub_service(service)
.build_with_executor(exc.clone().into())
.await
.expect("Build rpc server");
// Run the backend
backend.run().await.expect("Run p2p backend");
// Run the RPC server
server.start().await;
// Wait for ctrlc signal
ctrlc_r.recv().await.expect("Wait for ctrlc signal");
// Shutdown the backend
backend.shutdown().await;
// Shutdown the RPC server
server.shutdown().await;
},
ex,
);
}
|
