blob: 3215400eccbe5b2d278a0fb99c6ec1ada167c75b [file] [log] [blame]
// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use {
anyhow::{anyhow, Error},
diagnostics_reader::{ArchiveReader, Inspect},
fidl::endpoints::ServerEnd,
fidl_fuchsia_component as fcomponent, fidl_fuchsia_io as fio,
fidl_fuchsia_modular_internal as fmodular, fidl_fuchsia_session as fsession,
fidl_fuchsia_sys as fsys, fuchsia_async as fasync,
fuchsia_component::server::ServiceFs,
fuchsia_component_test::{
Capability, ChildOptions, ChildRef, LocalComponentHandles, RealmBuilder, Ref, Route,
},
futures::{channel::mpsc, future::join_all, prelude::*},
std::sync::Arc,
vfs::{directory::entry::DirectoryEntry, file::vmo::read_only_static, pseudo_directory},
};
const BASEMGR_URL: &str = "#meta/basemgr.cm";
const MOCK_COBALT_URL: &str = "#meta/mock_cobalt.cm";
const SESSIONMGR_URL: &str = "fuchsia-pkg://fuchsia.com/sessionmgr#meta/sessionmgr.cmx";
struct TestFixture {
pub builder: RealmBuilder,
pub basemgr: ChildRef,
pub placeholder: ChildRef,
}
impl TestFixture {
async fn new(basemgr_url: &str) -> Result<TestFixture, Error> {
let config_data_dir = pseudo_directory! {
"basemgr" => pseudo_directory! {
"startup.config" => read_only_static(r#"{ "basemgr": { "enable_cobalt": false } }"#),
},
};
let builder = RealmBuilder::new().await?;
// Add a local component that provides the `config-data` directory to the realm.
let config_data_server = builder
.add_local_child(
"config-data-server",
move |handles| {
let proxy = spawn_vfs(config_data_dir.clone());
async move {
let _ = &handles;
let mut fs = ServiceFs::new();
fs.add_remote("config-data", proxy);
fs.serve_connection(handles.outgoing_dir.into_channel())
.expect("failed to serve config-data ServiceFs");
fs.collect::<()>().await;
Ok::<(), anyhow::Error>(())
}
.boxed()
},
ChildOptions::new(),
)
.await?;
// Add mock_cobalt to the realm.
let mock_cobalt =
builder.add_child("mock_cobalt", MOCK_COBALT_URL, ChildOptions::new()).await?;
builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.logger.LogSink"))
.from(Ref::parent())
.to(&mock_cobalt),
)
.await?;
// Add basemgr to the realm.
let basemgr =
builder.add_child("basemgr", basemgr_url, ChildOptions::new().eager()).await?;
builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name(
"fuchsia.metrics.MetricEventLoggerFactory",
))
.from(&mock_cobalt)
.to(&basemgr),
)
.await?;
builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.logger.LogSink"))
.from(Ref::parent())
.to(&basemgr),
)
.await?;
builder
.add_route(
Route::new()
.capability(
Capability::directory("config-data")
.path("/config-data")
.rights(fio::R_STAR_DIR),
)
.from(&config_data_server)
.to(&basemgr),
)
.await?;
builder
.add_route(
Route::new()
.capability(Capability::storage("cache"))
.from(Ref::parent())
.to(&basemgr),
)
.await?;
builder
.add_route(
Route::new()
.capability(Capability::storage("data"))
.from(Ref::parent())
.to(&basemgr),
)
.await?;
// Add a placeholder component and routes for capabilities that are not
// expected to be used in this test scenario.
let placeholder = builder
.add_local_child(
"placeholder",
|_: LocalComponentHandles| Box::pin(async move { Ok(()) }),
ChildOptions::new(),
)
.await?;
builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.tracing.provider.Registry"))
.capability(Capability::protocol_by_name("fuchsia.ui.policy.Presenter"))
.capability(Capability::protocol_by_name(
"fuchsia.hardware.power.statecontrol.Admin",
))
.from(&placeholder)
.to(&basemgr),
)
.await?;
return Ok(TestFixture { builder, basemgr, placeholder });
}
async fn route_noop_sys_launcher(self) -> Result<TestFixture, Error> {
let sys_launcher = self
.builder
.add_local_child(
"sys_launcher",
move |handles| Box::pin(sys_launcher_noop(handles)),
ChildOptions::new(),
)
.await?;
let () = self
.builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.sys.Launcher"))
.from(&sys_launcher)
.to(&self.basemgr),
)
.await?;
Ok(self)
}
// Vend a placeholder implementation `fuchsia.session.Restarter`
// because this test doesn't expect to have this protocol exercised.
async fn route_placeholder_restarter(self) -> Result<TestFixture, Error> {
let () = self
.builder
.add_route(
Route::new()
.capability(Capability::protocol::<fsession::RestarterMarker>())
.from(&self.placeholder)
.to(&self.basemgr),
)
.await?;
Ok(self)
}
// Vend a `fuchsia.session.Restarter` implementation that sends a message on
// `restarter_sender` when the client calls `Restart`.
async fn route_restarter_with_sender(
self,
sender: mpsc::Sender<()>,
) -> Result<TestFixture, Error> {
let restarter = self
.builder
.add_local_child(
"restarter_with_sender",
move |handles| Box::pin(restarter_with_sender_impl(sender.clone(), handles)),
ChildOptions::new(),
)
.await?;
let () = self
.builder
.add_route(
Route::new()
.capability(Capability::protocol::<fsession::RestarterMarker>())
.from(&restarter)
.to(&self.basemgr),
)
.await?;
Ok(self)
}
}
// Tests that the session launches sessionmgr as a child v1 component.
#[fuchsia::test]
async fn test_launch_sessionmgr() -> Result<(), Error> {
// Add a local component that serves `fuchsia.sys.Launcher` to the realm.
let (launch_info_sender, launch_info_receiver) = mpsc::channel(1);
let fixture = TestFixture::new(BASEMGR_URL).await?.route_placeholder_restarter().await?;
let sys_launcher = fixture
.builder
.add_local_child(
"sys_launcher",
move |handles| Box::pin(sys_launcher_local_child(launch_info_sender.clone(), handles)),
ChildOptions::new(),
)
.await?;
let () = fixture
.builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.sys.Launcher"))
.from(&sys_launcher)
.to(&fixture.basemgr),
)
.await?;
let _instance = fixture.builder.build().await?;
// The session should have started sessionmgr as a v1 component.
let launch_info =
launch_info_receiver.take(1).next().await.ok_or_else(|| anyhow!("expected LaunchInfo"))?;
assert_eq!(SESSIONMGR_URL, launch_info.url);
Ok(())
}
// Serves an implementation of the `fuchsia.sys.Launcher` protocol that forwards
// the `LaunchInfo` of created components to `launch_info_sender`.
async fn sys_launcher_local_child(
launch_info_sender: mpsc::Sender<fsys::LaunchInfo>,
handles: LocalComponentHandles,
) -> Result<(), Error> {
let mut fs = ServiceFs::new();
fs.dir("svc").add_fidl_service(move |mut stream: fsys::LauncherRequestStream| {
let mut launch_info_sender = launch_info_sender.clone();
fasync::Task::local(async move {
while let Some(fsys::LauncherRequest::CreateComponent {
launch_info,
controller,
control_handle: _,
}) = stream.try_next().await.expect("failed to serve Launcher")
{
let mut controller_stream = controller
.unwrap()
.into_stream()
.expect("failed to create stream of ComponentController requests");
fasync::Task::spawn(async move {
if let Some(request) = controller_stream.try_next().await.unwrap() {
panic!("Unexpected ComponentController request: {:?}", request);
}
})
.detach();
launch_info_sender.try_send(launch_info).expect("failed to send LaunchInfo");
}
})
.detach();
});
fs.serve_connection(handles.outgoing_dir.into_channel())?;
fs.collect::<()>().await;
Ok(())
}
// Tests that basemgr will launch all of connect to all Binder connections
// in its namespace by passing in in child names via the "--eager-child" flag.
// In production, basemgr will have actual child components and will have
// fuchsia.component.Binder entries as a result of "use from child" clauses.
// However, in this test, basemgr will not have any child components but will
// have the expected Binder protocols routed to it via Realm Builder below.
// This allows us to use a local component implementation to assert that basemgr
// does in fact connect to expected Binder path.
#[fuchsia::test]
async fn test_launch_v2_eager_children() -> Result<(), Error> {
const NUM_TRIES: usize = 2;
const BASEMGR_WITH_EAGER_CHILDREN_URL: &str = "#meta/basemgr-with-eager-children.cm";
const EAGER_CHILDREN: [&str; 2] = ["foo", "bar"];
let fixture = TestFixture::new(BASEMGR_WITH_EAGER_CHILDREN_URL)
.await?
.route_placeholder_restarter()
.await?
.route_noop_sys_launcher()
.await?;
let mut child_restart_futs = vec![];
for child_name in EAGER_CHILDREN.iter() {
let binder_path = format!("fuchsia.component.Binder.{}", child_name);
// The function |basemgr_child_impl| is structured such that when it
// encounters a connection to the Binder protocol, it will exit. This will
// trigger a component Stopped event which should notify `basemgr` that the
// component exited. This is repeated to ensure that `basemgr` not only
// starts the component, but also that it restarts it.
let (binder_sender, binder_receiver) = mpsc::channel(NUM_TRIES);
let binder_path_clone = binder_path.clone();
let local_child = fixture
.builder
.add_local_child(
child_name.to_string(),
move |handles| {
Box::pin(basemgr_child_impl(
binder_sender.clone(),
binder_path.clone(),
handles,
))
},
ChildOptions::new(),
)
.await?;
fixture
.builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name(binder_path_clone))
.from(&local_child)
.to(&fixture.basemgr),
)
.await?;
let fut = async move {
let mut stream = binder_receiver.take(NUM_TRIES);
for _ in 0..NUM_TRIES {
let binder_connected = stream.next().await.unwrap();
assert!(binder_connected);
}
};
child_restart_futs.push(fut);
}
let instance = fixture.builder.build().await?;
let _ = join_all(child_restart_futs).await;
// We have to destroy the instance after the test assertion because
// basemgr teardown will be spammy with error logs due to closing sessionmgr's
// ComponentController channel
instance.destroy().await?;
Ok(())
}
// Tests that failure to connect to critical children will yield a session restart.
// This is accomplished by *not* routing `fuchsia.component.Binder` to the
// basemgr component. basemgr will encounter PEER_CLOSED and trigger a session
// restart by calling |fuchsia.session/Restarter.Restart|.
#[fuchsia::test]
async fn test_restart_session_after_critical_child_crashes() -> Result<(), Error> {
const BASEMGR_WITH_CRITICAL_CHILDREN_URL: &str = "#meta/basemgr-with-critical-children.cm";
let (restart_sender, restart_receiver) = mpsc::channel(1);
let fixture = TestFixture::new(BASEMGR_WITH_CRITICAL_CHILDREN_URL)
.await?
.route_restarter_with_sender(restart_sender)
.await?
.route_noop_sys_launcher()
.await?;
let instance = fixture.builder.build().await?;
let restart_requested = restart_receiver.take(1).next().await.is_some();
assert!(restart_requested);
// We have to destroy the instance after the test assertion because
// basemgr teardown will be spammy with error logs due to closing sessionmgr's
// ComponentController channel
instance.destroy().await?;
Ok(())
}
// Tests that sessionmgr crashing will yield a session restart.
#[fuchsia::test]
async fn test_restart_session_after_sessionmgr_crashes() -> Result<(), Error> {
let (restart_sender, restart_receiver) = mpsc::channel(1);
let fixture =
TestFixture::new(BASEMGR_URL).await?.route_restarter_with_sender(restart_sender).await?;
let sys_launcher = fixture
.builder
.add_local_child(
"sys_launcher",
move |handles| Box::pin(sys_launcher_crash(handles)),
ChildOptions::new(),
)
.await?;
let () = fixture
.builder
.add_route(
Route::new()
.capability(Capability::protocol_by_name("fuchsia.sys.Launcher"))
.from(&sys_launcher)
.to(&fixture.basemgr),
)
.await?;
let instance = fixture.builder.build().await?;
let restart_requested = restart_receiver.take(1).next().await.is_some();
assert!(restart_requested);
// We have to destroy the instance after the test assertion because
// basemgr teardown will be spammy with error logs due to closing sessionmgr's
// ComponentController channel
instance.destroy().await?;
Ok(())
}
// Tests that restart attempts for eager children are tracked in Inspect.
// The expectation is that basemgr emits the data in the Inspect tree like this:
// root:
// ...
// eager_children_restarts:
// some_child_name: 2
// some_other_name: 0
//
#[fuchsia::test]
async fn test_eager_children_restart_are_tracked_in_inspect() -> Result<(), Error> {
const MAX_RESTART_ATTEMPTS: u64 = 3;
const RESTART_TRACKER_PROP_KEY: &str = "eager_children_restarts";
const BASEMGR_WITH_EAGER_CHILDREN_URL: &str = "#meta/basemgr-with-eager-children.cm";
const EAGER_CHILDREN: [&str; 2] = ["foo", "bar"];
let fixture = TestFixture::new(BASEMGR_WITH_EAGER_CHILDREN_URL)
.await?
.route_placeholder_restarter()
.await?
.route_noop_sys_launcher()
.await?;
let instance = fixture.builder.build().await?;
let moniker = format!("realm_builder\\:{}/basemgr", instance.root.child_name());
let mut child_restart_futs = vec![];
for child_name in EAGER_CHILDREN.iter() {
let moniker = moniker.clone();
let fut = async move {
// We don't know when the restart attempts will added to Inspect.
// So in order to prevent a race condition where we assert that the
// the final count is MAX_RESTART_ATTEMPTS before basemgr has
// actually written that, we'll loop until that is the case.
// We can consider that exit condition the "assertion" of this test
// case.
loop {
let results = ArchiveReader::new()
.add_selector(format!("{}:root/eager_children_restarts", moniker))
.snapshot::<Inspect>()
.await
.unwrap();
assert_eq!(results.len(), 1);
// First, fetch the root node's payload.
let payload = results.first().unwrap().payload.as_ref().unwrap();
// Then, fetch child node namd `eager_children_restarts`.
let payload = payload.get_child(RESTART_TRACKER_PROP_KEY).unwrap();
let prop = payload.get_property(child_name).unwrap().uint().unwrap();
assert!(!prop > MAX_RESTART_ATTEMPTS);
// Sadly, Rust doesn't implement Eq trait for &u64 and u64.
if prop == &MAX_RESTART_ATTEMPTS {
break;
}
}
};
child_restart_futs.push(fut);
}
let _ = join_all(child_restart_futs).await;
// We have to destroy the instance after the test assertion because
// basemgr teardown will be spammy with error logs due to closing sessionmgr's
// ComponentController channel
instance.destroy().await?;
Ok(())
}
// Local implementation that pretends to be a basemgr child. Its connection
// to |fuchsia.component.Binder| is used to signal to basemgr that its still
// running. If this function receives a signal on |binder_sender| it will exit,
// thus closing the Binder channel that basemgr holds.
async fn basemgr_child_impl(
mut binder_sender: mpsc::Sender<bool>,
binder_path: String,
handles: LocalComponentHandles,
) -> Result<(), Error> {
// This check is added here because basemgr will continue to attempts restart
// of this child component after the test assertions in |test_launch_v2_children|
// completes.
if binder_sender.is_closed() {
return Ok(());
}
let (mut reboot_sender, reboot_receiver) = mpsc::channel(1);
let svc_fut = async move {
let _ = &handles;
let mut fs = ServiceFs::new();
fs.dir("svc").add_fidl_service_at(
binder_path,
move |_stream: fcomponent::BinderRequestStream| {
binder_sender.try_send(true).expect("failed to send message");
reboot_sender.try_send(true).expect("failed to send message");
},
);
fs.serve_connection(handles.outgoing_dir.into_channel()).unwrap();
fs.collect::<()>().await;
}
.fuse();
futures::pin_mut!(svc_fut);
let reboot_fut = async move {
reboot_receiver.take(1).next().await.unwrap();
}
.fuse();
futures::pin_mut!(reboot_fut);
futures::select! {
_ = svc_fut => panic!("vfs server should not stop"),
_ = reboot_fut => {}
}
Ok(())
}
async fn restarter_with_sender_impl(
restart_sender: mpsc::Sender<()>,
handles: LocalComponentHandles,
) -> Result<(), Error> {
let mut fs = ServiceFs::new();
fs.dir("svc").add_fidl_service(move |mut stream: fsession::RestarterRequestStream| {
let mut restart_sender = restart_sender.clone();
fasync::Task::local(async move {
while let Some(request) = stream.try_next().await.unwrap() {
match request {
fsession::RestarterRequest::Restart { .. } => {
restart_sender.try_send(()).expect("failed to send message");
}
}
}
})
.detach();
});
fs.serve_connection(handles.outgoing_dir.into_channel()).unwrap();
fs.collect::<()>().await;
Ok(())
}
// Returns a `DirectoryProxy` that serves the directory entry `dir`.
fn spawn_vfs(dir: Arc<dyn DirectoryEntry>) -> fio::DirectoryProxy {
let (client_end, server_end) =
fidl::endpoints::create_endpoints::<fio::DirectoryMarker>().unwrap();
let scope = vfs::execution_scope::ExecutionScope::new();
dir.open(
scope,
fio::OpenFlags::RIGHT_READABLE,
0,
vfs::path::Path::dot(),
ServerEnd::new(server_end.into_channel()),
);
client_end.into_proxy().unwrap()
}
// Implements a `fuchsia.sys.Launcher` that drops the controller passed to
// `CreateComponent`, simulating the component crashing instantly.
async fn sys_launcher_crash(handles: LocalComponentHandles) -> Result<(), Error> {
let mut fs = ServiceFs::new();
fs.dir("svc").add_fidl_service(|mut stream: fsys::LauncherRequestStream| {
fasync::Task::local(async move {
while let Some(request) = stream.try_next().await.expect("failed to serve Launcher") {
match request {
fsys::LauncherRequest::CreateComponent {
launch_info: _,
controller: _,
control_handle: _,
} => {
// Do nothing; controller is dropped.
}
}
}
})
.detach();
});
fs.serve_connection(handles.outgoing_dir.into_channel())?;
fs.collect::<()>().await;
Ok(())
}
// Implements a `fuchsia.sys.Launcher` that launches a component that does nothing but
// serve its outgoing directory.
async fn sys_launcher_noop(handles: LocalComponentHandles) -> Result<(), Error> {
let mut fs = ServiceFs::new();
fs.dir("svc").add_fidl_service(|mut stream: fsys::LauncherRequestStream| {
fasync::Task::local(async move {
while let Some(request) = stream.try_next().await.expect("failed to serve Launcher") {
match request {
fsys::LauncherRequest::CreateComponent {
launch_info,
controller,
control_handle: _,
} => {
let () = serve_sessionmgr(
launch_info
.directory_request
.expect("no fio::DirectoryRequest received"),
controller.unwrap(),
)
.await
.unwrap();
}
}
}
})
.detach();
});
fs.serve_connection(handles.outgoing_dir.into_channel())?;
fs.collect::<()>().await;
Ok(())
}
// We keep a reference to |_controller| to ensure the that channel doesn't close
// while Sessionmgr is being served.
async fn serve_sessionmgr(
channel: fidl::Channel,
_controller: fidl::endpoints::ServerEnd<fsys::ComponentControllerMarker>,
) -> Result<(), Error> {
let mut fs = ServiceFs::new();
fs.add_fidl_service(move |mut stream: fmodular::SessionmgrRequestStream| {
fasync::Task::local(async move { while let Some(_) = stream.try_next().await.unwrap() {} })
.detach();
});
fs.serve_connection(channel)?;
fs.collect::<()>().await;
Ok(())
}