1use massa_bootstrap::white_black_list::SharedWhiteBlackList;
4use massa_models::node::NodeId;
5use massa_versioning::keypair_factory::KeyPairFactory;
6use massa_versioning::versioning::MipStore;
7use parking_lot::RwLock;
8use std::convert::Infallible;
9use std::path::Path;
10use std::sync::{Arc, Condvar, Mutex};
11
12use crate::config::{GrpcConfig, ServiceName};
13use crate::error::GrpcError;
14use futures_util::FutureExt;
15use hyper::{Method, Request, Response};
16use massa_consensus_exports::{ConsensusBroadcasts, ConsensusController};
17use massa_execution_exports::{ExecutionChannels, ExecutionController};
18use massa_pool_exports::{PoolBroadcasts, PoolController};
19use massa_pos_exports::SelectorController;
20use massa_proto_rs::massa::api::v1::{
21 private_service_server::PrivateServiceServer, public_service_server::PublicServiceServer,
22};
23use massa_proto_rs::massa::api::v1::{FILE_DESCRIPTOR_SET_PRIVATE, FILE_DESCRIPTOR_SET_PUBLIC};
24use massa_protocol_exports::{ProtocolConfig, ProtocolController};
25use massa_sdk::cert_manager::{gen_cert_for_ca, gen_signed_cert};
26use massa_storage::Storage;
27
28use massa_wallet::Wallet;
29
30use tokio::sync::oneshot;
31use tonic::body::Body;
32use tonic::codegen::CompressionEncoding;
33use tonic::server::NamedService;
34use tonic::transport::{Certificate, Identity, ServerTlsConfig};
35use tonic_health::server::HealthReporter;
36use tonic_web::GrpcWebLayer;
37use tower_http::cors::{Any, CorsLayer};
38use tracing::{info, warn};
39
40#[derive(Clone)]
42pub struct MassaPrivateGrpc {
43 pub consensus_controller: Box<dyn ConsensusController>,
45 pub execution_controller: Box<dyn ExecutionController>,
47 pub pool_controller: Box<dyn PoolController>,
49 pub protocol_controller: Box<dyn ProtocolController>,
51 pub stop_cv: Arc<(Mutex<bool>, Condvar)>,
54 pub node_wallet: Arc<RwLock<Wallet>>,
56 pub grpc_config: GrpcConfig,
58 pub protocol_config: ProtocolConfig,
60 pub node_id: NodeId,
62 pub mip_store: MipStore,
64 pub version: massa_models::version::Version,
66 pub bs_white_black_list: Option<SharedWhiteBlackList<'static>>,
68}
69
70impl MassaPrivateGrpc {
71 pub async fn serve(self, config: &GrpcConfig) -> Result<StopHandle, GrpcError> {
73 let mut service = PrivateServiceServer::new(self)
74 .max_decoding_message_size(config.max_decoding_message_size)
75 .max_encoding_message_size(config.max_encoding_message_size);
76
77 if let Some(encoding) = &config.accept_compressed {
78 if encoding.eq_ignore_ascii_case("Gzip") {
79 service = service.accept_compressed(CompressionEncoding::Gzip);
80 };
81 }
82
83 if let Some(encoding) = &config.send_compressed {
84 if encoding.eq_ignore_ascii_case("Gzip") {
85 service = service.send_compressed(CompressionEncoding::Gzip);
86 };
87 }
88
89 serve(service, config).await
90 }
91}
92
93#[derive(Clone)]
95pub struct MassaPublicGrpc {
96 pub consensus_controller: Box<dyn ConsensusController>,
98 pub consensus_broadcasts: ConsensusBroadcasts,
100 pub execution_controller: Box<dyn ExecutionController>,
102 pub execution_channels: ExecutionChannels,
104 pub pool_broadcasts: PoolBroadcasts,
106 pub pool_controller: Box<dyn PoolController>,
108 pub protocol_controller: Box<dyn ProtocolController>,
110 pub selector_controller: Box<dyn SelectorController>,
112 pub storage: Storage,
114 pub grpc_config: GrpcConfig,
116 pub protocol_config: ProtocolConfig,
118 pub node_id: NodeId,
120 pub version: massa_models::version::Version,
122 pub keypair_factory: KeyPairFactory,
124}
125
126impl MassaPublicGrpc {
127 pub async fn serve(self, config: &GrpcConfig) -> Result<StopHandle, GrpcError> {
129 let mut service = PublicServiceServer::new(self)
130 .max_decoding_message_size(config.max_decoding_message_size)
131 .max_encoding_message_size(config.max_encoding_message_size);
132
133 if let Some(encoding) = &config.accept_compressed {
134 if encoding.eq_ignore_ascii_case("Gzip") {
135 service = service.accept_compressed(CompressionEncoding::Gzip);
136 };
137 }
138
139 if let Some(encoding) = &config.send_compressed {
140 if encoding.eq_ignore_ascii_case("Gzip") {
141 service = service.send_compressed(CompressionEncoding::Gzip);
142 };
143 }
144 serve(service, config).await
145 }
146}
147
148pub struct StopHandle {
150 stop_cmd_sender: oneshot::Sender<()>,
151}
152
153impl StopHandle {
154 pub fn stop(self) {
156 if let Err(e) = self.stop_cmd_sender.send(()) {
157 warn!("gRPC API thread panicked: {:?}", e);
158 } else {
159 info!("gRPC API stop signal sent successfully");
160 }
161 }
162}
163
164async fn massa_service_status(reporter: HealthReporter) {
166 reporter
168 .set_serving::<PublicServiceServer<MassaPublicGrpc>>()
169 .await;
170}
171
172pub(crate) fn check_mtls_requires_tls(config: &GrpcConfig) -> Result<(), GrpcError> {
178 massa_sdk::check_mtls_requires_tls(config.enable_tls, config.enable_mtls)
179 .map_err(|err| GrpcError::ConfigError(format!("gRPC {:?} API: {}", config.name, err)))
180}
181
182async fn serve<S>(service: S, config: &GrpcConfig) -> Result<StopHandle, GrpcError>
184where
185 S: tower_service::Service<Request<Body>, Response = Response<Body>, Error = Infallible>
186 + NamedService
187 + Clone
188 + Send
189 + Sync
190 + 'static,
191 S::Future: Send + 'static,
192{
193 check_mtls_requires_tls(config)?;
194
195 let (shutdown_send, shutdown_recv) = oneshot::channel::<()>();
196
197 let mut server_builder = tonic::transport::Server::builder()
198 .concurrency_limit_per_connection(config.concurrency_limit_per_connection)
199 .timeout(config.timeout)
200 .initial_stream_window_size(config.initial_stream_window_size)
201 .initial_connection_window_size(config.initial_connection_window_size)
202 .max_concurrent_streams(config.max_concurrent_streams)
203 .tcp_keepalive(config.tcp_keepalive)
204 .tcp_nodelay(config.tcp_nodelay)
205 .http2_keepalive_interval(config.http2_keepalive_interval)
206 .http2_keepalive_timeout(config.http2_keepalive_timeout)
207 .http2_adaptive_window(config.http2_adaptive_window)
208 .max_frame_size(config.max_frame_size);
209
210 if config.enable_tls {
211 if config.generate_self_signed_certificates {
212 if Path::new(&config.certificate_authority_root_path).exists() {
213 warn!("Certificate authority root already exists, remove the file if you want to generate new certificates. Skipping self signed certificates generation.");
214 } else {
215 info!("Generating self signed certificates");
216 generate_self_signed_certificates(config);
217 }
218 }
219
220 let cert = std::fs::read_to_string(config.server_certificate_path.clone())
221 .expect("error, failed to read server certificate");
222 let key = std::fs::read_to_string(config.server_private_key_path.clone())
223 .expect("error, failed to read server private key");
224
225 let server_identity = Identity::from_pem(cert, key);
226 let tls = ServerTlsConfig::new().identity(server_identity);
227
228 if config.enable_mtls {
229 let client_ca_cert =
230 std::fs::read_to_string(config.client_certificate_authority_root_path.clone())
231 .expect("error, failed to read client certificate authority root");
232 let client_ca_cert = Certificate::from_pem(client_ca_cert);
233
234 let tls = tls.client_ca_root(client_ca_cert);
235
236 server_builder = server_builder
237 .tls_config(tls)
238 .expect("error, failed to setup mTLS");
239
240 info!("gRPC mTLS enabled");
241 } else {
242 server_builder = server_builder
243 .tls_config(tls)
244 .expect("error, failed to setup TLS");
245 info!("gRPC TLS enabled");
246 }
247 }
248
249 let reflection_service_opt_alpha = if config.enable_reflection {
250 let file_descriptor_set = match config.name {
251 ServiceName::Public => FILE_DESCRIPTOR_SET_PUBLIC,
252 ServiceName::Private => FILE_DESCRIPTOR_SET_PRIVATE,
253 };
254 let reflection_service = tonic_reflection::server::Builder::configure()
255 .register_encoded_file_descriptor_set(file_descriptor_set)
256 .build_v1alpha()?;
257
258 Some(reflection_service)
259 } else {
260 None
261 };
262
263 let reflection_service_opt = if config.enable_reflection {
264 let file_descriptor_set = match config.name {
265 ServiceName::Public => FILE_DESCRIPTOR_SET_PUBLIC,
266 ServiceName::Private => FILE_DESCRIPTOR_SET_PRIVATE,
267 };
268 let reflection_service = tonic_reflection::server::Builder::configure()
269 .register_encoded_file_descriptor_set(file_descriptor_set)
270 .build_v1()?;
271
272 Some(reflection_service)
273 } else {
274 None
275 };
276
277 let health_service_opt = if config.enable_health {
278 let (health_reporter, health_service) = tonic_health::server::health_reporter();
279 health_reporter
280 .set_serving::<PublicServiceServer<MassaPublicGrpc>>()
281 .await;
282 tokio::spawn(massa_service_status(health_reporter.clone()));
283 info!("gRPC health service enabled");
284 Some(health_service)
285 } else {
286 None
287 };
288
289 if config.accept_http1 {
290 if config.enable_cors {
291 let cors = CorsLayer::new()
292 .allow_methods([Method::GET, Method::POST, Method::OPTIONS])
294 .allow_origin(Any)
296 .allow_headers(Any);
297
298 let router_with_http1 = server_builder
299 .accept_http1(true)
300 .layer(cors)
301 .layer(GrpcWebLayer::new())
302 .add_optional_service(reflection_service_opt)
303 .add_optional_service(reflection_service_opt_alpha)
304 .add_optional_service(health_service_opt)
305 .add_service(service);
306
307 tokio::spawn(
308 router_with_http1.serve_with_shutdown(config.bind, shutdown_recv.map(drop)),
309 );
310 } else {
311 let router_with_http1 = server_builder
312 .accept_http1(true)
313 .layer(GrpcWebLayer::new())
314 .add_optional_service(reflection_service_opt)
315 .add_optional_service(reflection_service_opt_alpha)
316 .add_optional_service(health_service_opt)
317 .add_service(service);
318
319 tokio::spawn(
320 router_with_http1.serve_with_shutdown(config.bind, shutdown_recv.map(drop)),
321 );
322 }
323 } else {
324 let router = server_builder
325 .add_optional_service(reflection_service_opt)
326 .add_optional_service(reflection_service_opt_alpha)
327 .add_optional_service(health_service_opt)
328 .add_service(service);
329
330 tokio::spawn(router.serve_with_shutdown(config.bind, shutdown_recv.map(drop)));
331 }
332
333 Ok(StopHandle {
334 stop_cmd_sender: shutdown_send,
335 })
336}
337
338fn generate_self_signed_certificates(config: &GrpcConfig) {
340 let ca_cert = gen_cert_for_ca().expect("error, failed to generate CA cert");
341 let ca_cert_pem = ca_cert
342 .serialize_pem()
343 .expect("error: failed to convert certificate authority to UTF-8");
344
345 if config.enable_mtls {
346 std::fs::write(
347 config.client_certificate_authority_root_path.clone(),
348 ca_cert_pem.clone(),
349 )
350 .expect("error, failed to write client certificate authority root");
351
352 let (client_cert_pem, client_private_key_pem) =
353 gen_signed_cert(&ca_cert, config.subject_alt_names.clone())
354 .expect("error, failed to generate cert");
355 std::fs::write(config.client_certificate_path.clone(), client_cert_pem)
356 .expect("error, failed to write client certificate");
357 std::fs::write(
358 config.client_private_key_path.clone(),
359 client_private_key_pem,
360 )
361 .expect("error, failed to write client private key");
362 }
363
364 std::fs::write(config.certificate_authority_root_path.clone(), ca_cert_pem)
365 .expect("error, failed to write certificate authority root");
366
367 let (cert_pem, server_private_key_pem) =
368 gen_signed_cert(&ca_cert, config.subject_alt_names.clone())
369 .expect("error, failed to generate server certificate");
370 std::fs::write(config.server_certificate_path.clone(), cert_pem)
371 .expect("error, failed to write server certificate");
372 std::fs::write(
373 config.server_private_key_path.clone(),
374 server_private_key_pem,
375 )
376 .expect("error, failed to write server private key");
377}