1use crate::accessor::{ArchiveAccessorServer, BatchRetrievalTimeout};
6use crate::component_lifecycle;
7use crate::error::Error;
8use crate::events::router::{ConsumerConfig, EventRouter, ProducerConfig};
9use crate::events::sources::EventSource;
10use crate::events::types::*;
11use crate::inspect::repository::InspectRepository;
12use crate::inspect::servers::*;
13use crate::logs::debuglog::KernelDebugLog;
14use crate::logs::repository::{ComponentInitialInterest, LogsRepository};
15use crate::logs::serial::{SerialSink, launch_serial};
16use crate::logs::servers::*;
17use crate::logs::shared_buffer::Buffer;
18use crate::pipeline::PipelineManager;
19use archivist_config::Config;
20use fidl_fuchsia_component_runtime as fruntime;
21use fidl_fuchsia_diagnostics as fdiagnostics;
22use fidl_fuchsia_process_lifecycle::LifecycleRequestStream;
23use fuchsia_async as fasync;
24use fuchsia_component::runtime::DictionaryRouterReceiver;
25use fuchsia_component::server::{ServiceFs, ServiceObj};
26use fuchsia_inspect::component;
27use fuchsia_inspect::health::Reporter;
28use futures::channel::mpsc::unbounded;
29use futures::prelude::*;
30use log::{debug, error, info, warn};
31use std::path::PathBuf;
32use std::str::FromStr;
33use std::sync::Arc;
34
35pub struct Archivist {
38 event_router: EventRouter,
40
41 pipeline_manager: PipelineManager,
43
44 _inspect_repository: Arc<InspectRepository>,
46
47 logs_repository: Arc<LogsRepository>,
49
50 accessor_server: Arc<ArchiveAccessorServer>,
52
53 log_server: Arc<LogServer>,
55
56 flush_server: Arc<LogFlushServer>,
58
59 _inspect_sink_server: Arc<InspectSinkServer>,
61
62 general_scope: fasync::Scope,
64
65 incoming_events_scope: fasync::Scope,
67
68 servers_scope: fasync::Scope,
70
71 freeze_server: LogFreezeServer,
73
74 sample_server: Arc<SampleServer>,
76
77 salt: [u8; fdiagnostics::SALT_SIZE as usize],
79}
80
81impl Archivist {
82 pub async fn new(ring_buffer: Buffer, config: Config) -> Self {
86 let general_scope = fasync::Scope::new_with_name("general");
87 let servers_scope = fasync::Scope::new_with_name("servers");
88
89 let pipeline_manager = PipelineManager::new(
91 PathBuf::from(&config.pipelines_path),
92 component::inspector().root().create_child("pipelines"),
93 component::inspector().root().create_child("archive_accessor_stats"),
94 general_scope.new_child_with_name("pipeline_manager"),
95 )
96 .await;
97
98 let mut event_router =
100 EventRouter::new(component::inspector().root().create_child("events"));
101 let incoming_events_scope = general_scope.new_child_with_name("incoming_events");
102 Self::initialize_external_event_sources(&mut event_router, &incoming_events_scope).await;
103
104 let initial_interests =
105 config.component_initial_interests.into_iter().filter_map(|interest| {
106 ComponentInitialInterest::from_str(&interest)
107 .map_err(|err| {
108 warn!(err:?, invalid:% = interest; "Failed to load initial interest");
109 })
110 .ok()
111 });
112 let logs_repo = LogsRepository::new(
113 ring_buffer,
114 initial_interests,
115 component::inspector().root(),
116 general_scope.new_child_with_name("logs_repository"),
117 );
118 let (freeze_server, freeze_receiver) = LogFreezeServer::new();
119 let (flush_sender, flush_receiver) = unbounded();
120 if !config.allow_serial_logs.is_empty() {
121 let logs_repo_clone = Arc::clone(&logs_repo);
122 general_scope.spawn(async move {
123 launch_serial(
124 config.allow_serial_logs,
125 config.deny_serial_log_tags,
126 logs_repo_clone,
127 SerialSink,
128 freeze_receiver,
129 flush_receiver,
130 )
131 .await;
132 });
133 }
134 let inspect_repo = Arc::new(InspectRepository::new(
135 pipeline_manager.weak_pipelines(),
136 general_scope.new_child_with_name("inspect_repository"),
137 ));
138
139 let inspect_sink_server = Arc::new(InspectSinkServer::new(
140 Arc::clone(&inspect_repo),
141 servers_scope.new_child_with_name("InspectSink"),
142 ));
143
144 let sample_server = Arc::new(SampleServer::new(
145 Arc::clone(&inspect_repo),
146 zx::MonotonicDuration::from_seconds(
147 config.fuchsia_diagnostics_sample_min_period_seconds,
148 ),
149 servers_scope.new_child_with_name("SampleServer"),
150 ));
151
152 let accessor_server = Arc::new(ArchiveAccessorServer::new(
154 Arc::clone(&inspect_repo),
155 Arc::clone(&logs_repo),
156 config.maximum_concurrent_snapshots_per_reader,
157 BatchRetrievalTimeout::from_seconds(config.per_component_batch_timeout_seconds),
158 servers_scope.new_child_with_name("ArchiveAccessor"),
159 ));
160
161 let flush_server = Arc::new(LogFlushServer::new(
162 servers_scope.new_child_with_name("LogFlush"),
163 flush_sender,
164 ));
165
166 let log_server = Arc::new(LogServer::new(
167 Arc::clone(&logs_repo),
168 servers_scope.new_child_with_name("Log"),
169 ));
170
171 event_router.add_consumer(ConsumerConfig {
174 consumer: &logs_repo,
175 events: vec![EventType::LogSinkRequested],
176 });
177 event_router.add_consumer(ConsumerConfig {
178 consumer: &inspect_sink_server,
179 events: vec![EventType::InspectSinkRequested],
180 });
181
182 if config.enable_klog {
184 match KernelDebugLog::new().await {
185 Ok(klog) => logs_repo.drain_debuglog(klog),
186 Err(err) => warn!(
187 err:?;
188 "Failed to start the kernel debug log reader. Klog won't be in syslog"
189 ),
190 };
191 }
192
193 for name in &config.bind_services {
195 info!("Connecting to service {}", name);
196 let (_local, remote) = zx::Channel::create();
197 if let Err(e) = fdio::service_connect(&format!("/svc/{name}"), remote) {
198 error!("Couldn't connect to service {}: {:?}", name, e);
199 }
200 }
201
202 let mut salt = [0u8; fdiagnostics::SALT_SIZE as usize];
203 zx::cprng_draw(&mut salt);
204
205 Self {
206 accessor_server,
207 log_server,
208 flush_server,
209 event_router,
210 _inspect_sink_server: inspect_sink_server,
211 pipeline_manager,
212 _inspect_repository: inspect_repo,
213 logs_repository: logs_repo,
214 general_scope,
215 servers_scope,
216 freeze_server,
217 incoming_events_scope,
218 sample_server,
219 salt,
220 }
221 }
222
223 pub async fn initialize_external_event_sources(
224 event_router: &mut EventRouter,
225 scope: &fasync::Scope,
226 ) {
227 match EventSource::new("/events/log_sink_requested_event_stream").await {
228 Err(err) => warn!(err:?; "Failed to create event source for log sink requests"),
229 Ok(mut event_source) => {
230 event_router.add_producer(ProducerConfig {
231 producer: &mut event_source,
232 events: vec![EventType::LogSinkRequested],
233 });
234 scope.spawn(async move {
235 let _ = event_source.spawn().await;
237 });
238 }
239 }
240
241 match EventSource::new("/events/inspect_sink_requested_event_stream").await {
242 Err(err) => {
243 warn!(err:?; "Failed to create event source for InspectSink requests");
244 }
245 Ok(mut event_source) => {
246 event_router.add_producer(ProducerConfig {
247 producer: &mut event_source,
248 events: vec![EventType::InspectSinkRequested],
249 });
250 scope.spawn(async move {
251 let _ = event_source.spawn().await;
253 });
254 }
255 }
256 }
257
258 pub async fn run(
262 mut self,
263 mut fs: ServiceFs<ServiceObj<'static, ()>>,
264 is_embedded: bool,
265 request_stream: LifecycleRequestStream,
266 ) -> Result<(), Error> {
267 debug!("Running Archivist.");
268
269 self.serve_protocols(&mut fs).await;
271 let svc_task = self.general_scope.spawn(fs.collect::<()>());
272
273 let _inspect_server_task = inspect_runtime::publish(
274 component::inspector(),
275 inspect_runtime::PublishOptions::default(),
276 );
277
278 let Self {
279 _inspect_repository,
280 mut pipeline_manager,
281 logs_repository,
282 accessor_server: _accessor_server,
283 log_server: _log_server,
284 _inspect_sink_server,
285 general_scope,
286 incoming_events_scope,
287 freeze_server: _freeze_server,
288 servers_scope,
289 event_router,
290 flush_server: _flush_server,
291 sample_server: _sample_server,
292 salt: _salt,
293 } = self;
294
295 let (terminate_handle, drain_events_fut) = event_router
297 .start()
298 .expect("Failed to start event router");
300 general_scope.spawn(drain_events_fut);
301
302 let servers_scope_handle = servers_scope.to_handle();
303 general_scope.spawn(component_lifecycle::on_stop_request(request_stream, || async move {
304 terminate_handle.terminate().await;
305 debug!("Stopped ingesting new CapabilityRequested events");
306 incoming_events_scope.cancel().await;
307 debug!("Cancel all tasks currently executing in our event router");
308 servers_scope_handle.close();
309 logs_repository.stop_accepting_new_log_sinks();
310 debug!("Close any new connections to FIDL servers");
311 svc_task.abort().await;
312 pipeline_manager.cancel().await;
313 debug!("Stop allowing new connections through the incoming namespace.");
314 logs_repository.wait_for_termination().await;
315 debug!("All LogSink connections have finished");
316 servers_scope.join().await;
317 debug!("All servers stopped.");
318 }));
319 if is_embedded {
320 debug!("Entering core loop.");
321 } else {
322 info!("archivist: Entering core loop.");
323 }
324
325 component::health().set_ok();
326 general_scope.await;
327
328 Ok(())
329 }
330
331 async fn serve_protocols(&mut self, fs: &mut ServiceFs<ServiceObj<'static, ()>>) {
332 component::serve_inspect_stats();
333 let mut svc_dir = fs.dir("svc");
334
335 let accessors_dict =
337 self.pipeline_manager.serve_pipelines(Arc::clone(&self.accessor_server)).await;
338
339 let log_server = Arc::clone(&self.log_server);
341 svc_dir.add_fidl_service(move |stream| {
342 debug!("fuchsia.logger.Log connection");
343 log_server.spawn(stream);
344 });
345
346 let flush_server = Arc::clone(&self.flush_server);
348 svc_dir.add_fidl_service(move |stream| {
349 debug!("fuchsia.diagnostics.system.LogFlush connection");
350 flush_server.spawn(stream);
351 });
352
353 self.sample_server.install_and_serve(&accessors_dict).await;
357
358 let server = self.freeze_server.clone();
359 let scope = self.general_scope.clone();
360
361 svc_dir.add_fidl_service(move |stream| {
362 debug!("fuchsia.diagnostics.system.SerialLogControl connection");
363 let server = server.clone();
364 scope.spawn(async move {
365 let _ = server.handle_requests(stream).await;
366 });
367 });
368
369 let log_settings_server = LogSettingsServer::new(
371 Arc::clone(&self.logs_repository),
372 self.general_scope.new_child_with_name("LogSettings"),
375 );
376 svc_dir.add_fidl_service(move |stream| {
377 debug!("fuchsia.diagnostics.LogSettings connection");
378 log_settings_server.spawn(stream);
379 });
380
381 let salt = self.salt;
383 let salt_scope = self.general_scope.new_child_with_name("SaltProvider");
384 svc_dir.add_fidl_service(move |stream: fdiagnostics::SaltProviderRequestStream| {
385 debug!("fuchsia.diagnostics.SaltProvider connection");
386 salt_scope.spawn(Self::serve_salt_provider(stream, salt));
387 });
388
389 let router_scope =
391 self.servers_scope.new_child_with_name("fuchsia.component.runtime.DictionaryRouter");
392 svc_dir.add_fidl_service(move |stream: fruntime::DictionaryRouterRequestStream| {
393 let accessors_dict = accessors_dict.clone();
394 let router_receiver = DictionaryRouterReceiver::from(stream);
395 router_scope.spawn(router_receiver.handle_with(move |_request, _instance_token| {
396 debug!("Got route request for the dynamic accessors dictionary");
397 futures::future::ready(Ok(Some(accessors_dict.clone()))).boxed()
398 }));
399 });
400 }
401
402 async fn serve_salt_provider(
403 mut stream: fdiagnostics::SaltProviderRequestStream,
404 salt: [u8; fdiagnostics::SALT_SIZE as usize],
405 ) {
406 while let Ok(Some(request)) = stream.try_next().await {
407 match request {
408 fdiagnostics::SaltProviderRequest::GetSalt { responder } => {
409 let _ = responder.send(&salt);
410 }
411 fdiagnostics::SaltProviderRequest::_UnknownMethod {
412 ordinal, method_type, ..
413 } => {
414 warn!(ordinal, method_type:?; "Unknown request on SaltProvider");
415 }
416 }
417 }
418 }
419}
420
421#[cfg(test)]
422mod tests {
423 use super::*;
424 use fidl::endpoints::create_proxy_and_stream;
425
426 #[fuchsia::test]
427 async fn salt_provider_returns_consistent_salt() {
428 let mut expected_salt = [0u8; fdiagnostics::SALT_SIZE as usize];
429 zx::cprng_draw(&mut expected_salt);
430
431 let scope = fasync::Scope::new();
432 let (proxy1, stream1) = create_proxy_and_stream::<fdiagnostics::SaltProviderMarker>();
433 let (proxy2, stream2) = create_proxy_and_stream::<fdiagnostics::SaltProviderMarker>();
434 scope.spawn(Archivist::serve_salt_provider(stream1, expected_salt));
435 scope.spawn(Archivist::serve_salt_provider(stream2, expected_salt));
436
437 let salt1 = proxy1.get_salt().await.expect("get_salt 1");
438 let salt2 = proxy2.get_salt().await.expect("get_salt 2");
439 assert_eq!(salt1, expected_salt);
440 assert_eq!(salt1, salt2);
441 assert_ne!(salt1, [0u8; fdiagnostics::SALT_SIZE as usize]);
442 }
443}