Skip to main content

archivist_lib/
archivist.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use 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
35/// Responsible for initializing an `Archivist` instance. Supports multiple configurations by
36/// either calling or not calling methods on the builder like `serve_test_controller_protocol`.
37pub struct Archivist {
38    /// Handles event routing between archivist parts.
39    event_router: EventRouter,
40
41    /// The diagnostics pipelines that have been installed.
42    pipeline_manager: PipelineManager,
43
44    /// The repository holding Inspect data.
45    _inspect_repository: Arc<InspectRepository>,
46
47    /// The repository holding active log connections.
48    logs_repository: Arc<LogsRepository>,
49
50    /// The server handling fuchsia.diagnostics.ArchiveAccessor
51    accessor_server: Arc<ArchiveAccessorServer>,
52
53    /// The server handling fuchsia.logger.Log
54    log_server: Arc<LogServer>,
55
56    /// The server handling fuchsia.diagnostics.system.LogFlush
57    flush_server: Arc<LogFlushServer>,
58
59    /// The server handling fuchsia.inspect.InspectSink
60    _inspect_sink_server: Arc<InspectSinkServer>,
61
62    /// Top level scope.
63    general_scope: fasync::Scope,
64
65    /// Tasks receiving external events from component manager.
66    incoming_events_scope: fasync::Scope,
67
68    /// All tasks for FIDL servers that ingest data into the Archivist must run in this scope.
69    servers_scope: fasync::Scope,
70
71    /// Freeze server.
72    freeze_server: LogFreezeServer,
73
74    /// The server handling fuchsia.diagnostics.Sample
75    sample_server: Arc<SampleServer>,
76
77    /// Per-boot random salt served by `fuchsia.diagnostics.SaltProvider`.
78    salt: [u8; fdiagnostics::SALT_SIZE as usize],
79}
80
81impl Archivist {
82    /// Creates new instance, sets up inspect and adds 'archive' directory to output folder.
83    /// Also installs `fuchsia.diagnostics.Archive` service.
84    /// Call `install_log_services`
85    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        // Initialize the pipelines that the archivist will expose.
90        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        // Initialize the core event router
99        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        // Initialize our FIDL servers. This doesn't start serving yet.
153        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        // Initialize the external event providers containing incoming diagnostics directories and
172        // log sink connections.
173        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        // Drain klog and publish it to syslog.
183        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        // Start related services that should start once the Archivist has started.
194        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                    // This should never exit.
236                    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                    // This should never exit.
252                    let _ = event_source.spawn().await;
253                });
254            }
255        }
256    }
257
258    /// Run archivist to completion.
259    /// # Arguments:
260    /// * `outgoing_channel`- channel to serve outgoing directory on.
261    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        // Start servicing all outgoing services.
270        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        // Start ingesting events.
296        let (terminate_handle, drain_events_fut) = event_router
297            .start()
298            // panic: can only panic if we didn't register event producers and consumers correctly.
299            .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        // Serve fuchsia.diagnostics.ArchiveAccessors backed by a pipeline.
336        let accessors_dict =
337            self.pipeline_manager.serve_pipelines(Arc::clone(&self.accessor_server)).await;
338
339        // Serve fuchsia.logger.Log
340        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        // Serve fuchsia.diagnostics.system.LogFlush
347        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        // Install sample server to the accessors dictionary and start serving.
354        // Note that the await is not awaiting on the request stream or anything like that;
355        // the server spawns onto its owned Scope.
356        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        // Server fuchsia.diagnostics.LogSettings
370        let log_settings_server = LogSettingsServer::new(
371            Arc::clone(&self.logs_repository),
372            // Don't create this in the servers scope. We don't care about this protocol for
373            // shutdown purposes.
374            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        // Serve fuchsia.diagnostics.SaltProvider
382        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        // Serve fuchsia.component.runtime.DictionaryRouter
390        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}