// Copyright 2020 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 crate::error::PowerManagerError;
use crate::message::{Message, MessageReturn};
use crate::node::Node;
use crate::shutdown_request::ShutdownRequest;
use crate::types::Seconds;
use crate::utils::connect_proxy;
use anyhow::{format_err, Error};
use async_trait::async_trait;
use fidl_fuchsia_hardware_power_statecontrol as fpowercontrol;
use fidl_fuchsia_sys2 as fsys;
use fuchsia_async::{self as fasync, DurationExt, TimeoutExt};
use fuchsia_component::server::{ServiceFs, ServiceObjLocal};
use fuchsia_inspect::{self as inspect, Property};
use fuchsia_zircon::{self as zx, Status as zx_status};
use futures::prelude::*;
use futures::TryStreamExt;
use log::*;
use serde_derive::Deserialize;
use serde_json as json;
use std::cell::Cell;
use std::collections::HashMap;
use std::rc::Rc;

/// Node: SystemShutdownHandler
///
/// Summary: Provides a mechanism for the Power Manager to shut down the system. In addition to
/// providing a shutdown mechanism for the Power Manager internally, this node hosts the
/// fuchsia.hardware.power.statecontrol protocol to support system shutdown for external components.
///
/// Handles Messages:
///     - SystemShutdown
///
/// Sends Messages:
///     - SetTerminationSystemState
///
/// FIDL dependencies:
///     - fuchsia.device.manager: this FIDL library provides the SystemPowerState enum that the
///       Driver Manager expects as an argument to its fuchsia.device.manager.SystemStateTransition
///       API.
///     - fuchsia.hardware.power.statecontrol.Admin: the node hosts a service of this protocol to
///       the rest of the system
///     - fuchsia.sys2.SystemController: the node uses this protocol to instruct the Component
///       Manager to shut down the component tree

/// A builder for constructing the SystemShutdownHandler node.
pub struct SystemShutdownHandlerBuilder<'a, 'b> {
    driver_manager_handler: Rc<dyn Node>,
    shutdown_watcher: Option<Rc<dyn Node>>,
    component_mgr_path: Option<String>,
    component_mgr_proxy: Option<fsys::SystemControllerProxy>,
    shutdown_timeout: Option<Seconds>,
    force_shutdown_func: Box<dyn Fn()>,
    service_fs: Option<&'a mut ServiceFs<ServiceObjLocal<'b, ()>>>,
    inspect_root: Option<&'a inspect::Node>,
}

impl<'a, 'b> SystemShutdownHandlerBuilder<'a, 'b> {
    pub fn new(driver_manager_handler: Rc<dyn Node>) -> Self {
        Self {
            driver_manager_handler,
            shutdown_watcher: None,
            component_mgr_path: None,
            component_mgr_proxy: None,
            shutdown_timeout: None,
            force_shutdown_func: Box::new(force_shutdown),
            service_fs: None,
            inspect_root: None,
        }
    }

    pub fn new_from_json(
        json_data: json::Value,
        nodes: &HashMap<String, Rc<dyn Node>>,
        service_fs: &'a mut ServiceFs<ServiceObjLocal<'b, ()>>,
    ) -> Self {
        #[derive(Deserialize)]
        struct Config {
            component_manager_path: String,
            shutdown_timeout_s: Option<f64>,
        }

        #[derive(Deserialize)]
        struct Dependencies {
            driver_manager_handler_node: String,
            shutdown_watcher_node: Option<String>,
        }

        #[derive(Deserialize)]
        struct JsonData {
            config: Config,
            dependencies: Dependencies,
        }

        let data: JsonData = json::from_value(json_data).unwrap();
        let mut builder = Self::new(nodes[&data.dependencies.driver_manager_handler_node].clone())
            .with_service_fs(service_fs)
            .with_component_mgr_path(data.config.component_manager_path);

        if let Some(timeout) = data.config.shutdown_timeout_s {
            builder = builder.with_shutdown_timeout(Seconds(timeout))
        }

        if let Some(watcher_name) = data.dependencies.shutdown_watcher_node {
            builder = builder.with_shutdown_watcher(nodes[&watcher_name].clone())
        }

        builder
    }

    pub fn with_component_mgr_path(mut self, path: String) -> Self {
        self.component_mgr_path = Some(path);
        self
    }

    pub fn with_service_fs(
        mut self,
        service_fs: &'a mut ServiceFs<ServiceObjLocal<'b, ()>>,
    ) -> Self {
        self.service_fs = Some(service_fs);
        self
    }

    pub fn with_shutdown_timeout(mut self, timeout: Seconds) -> Self {
        self.shutdown_timeout = Some(timeout);
        self
    }

    pub fn with_shutdown_watcher(mut self, watcher: Rc<dyn Node>) -> Self {
        self.shutdown_watcher = Some(watcher);
        self
    }

    #[cfg(test)]
    pub fn with_force_shutdown_function(
        mut self,
        force_shutdown: Box<impl Fn() + 'static>,
    ) -> Self {
        self.force_shutdown_func = force_shutdown;
        self
    }

    #[cfg(test)]
    pub fn with_component_mgr_proxy(mut self, proxy: fsys::SystemControllerProxy) -> Self {
        self.component_mgr_proxy = Some(proxy);
        self
    }

    #[cfg(test)]
    pub fn with_inspect_root(mut self, root: &'a inspect::Node) -> Self {
        self.inspect_root = Some(root);
        self
    }

    pub fn build(self) -> Result<Rc<SystemShutdownHandler>, Error> {
        // Optionally use the default inspect root node
        let inspect_root = self.inspect_root.unwrap_or(inspect::component::inspector().root());

        // Connect to the Component Manager's SystemController service if a proxy wasn't specified
        let component_mgr_proxy = if let Some(proxy) = self.component_mgr_proxy {
            proxy
        } else {
            connect_proxy::<fsys::SystemControllerMarker>(
                &self
                    .component_mgr_path
                    .ok_or(format_err!("Must specify Component Manager path or proxy"))?
                    .to_string(),
            )?
        };

        let node = Rc::new(SystemShutdownHandler {
            shutdown_timeout: self.shutdown_timeout,
            force_shutdown_func: self.force_shutdown_func,
            shutdown_pending: Cell::new(false),
            driver_mgr_handler: self.driver_manager_handler,
            shutdown_watcher: self.shutdown_watcher,
            component_mgr_proxy,
            inspect: InspectData::new(inspect_root, "SystemShutdownHandler".to_string()),
        });

        // Publish the service only if we were provided with a ServiceFs
        if let Some(service_fs) = self.service_fs {
            node.clone().publish_fidl_service(service_fs);
        }

        // Populate the config data into Inspect
        node.inspect.set_config(&node);

        Ok(node)
    }
}

pub struct SystemShutdownHandler {
    /// Maximum time to wait for an orderly shutdown using the Component Manager shutdown path. If
    /// the timeout expires before the orderly shutdown path is complete, a forced shutdown will
    /// occur. If the orderly shutdown path fails with an error, a forced shutdown will occur
    /// immediately. If no shutdown timeout is specified, a forced shutdown will occur immediately
    /// following the failed attempt.
    shutdown_timeout: Option<Seconds>,

    /// Function to force a system shutdown.
    force_shutdown_func: Box<dyn Fn()>,

    /// Tracks the current shutdown request state. Used to ignore shutdown requests while a current
    /// request is being processed.
    shutdown_pending: Cell<bool>,

    /// Reference to the DriverManagerHandler node. It is expected that this node responds to the
    /// SetTerminationSystemState message.
    driver_mgr_handler: Rc<dyn Node>,

    /// Optional reference to a SystemShutdownWatcher instance. There is no requirement that a node
    /// be populated in this Option. If one exists, then it will be notified of system shutdown
    /// events. If not, then no notifications are sent out for system shutdown events.
    shutdown_watcher: Option<Rc<dyn Node>>,

    /// Proxy handle to communicate with the Component Manager's SystemController protocol.
    component_mgr_proxy: fsys::SystemControllerProxy,

    /// Struct for managing Component Inspection data
    inspect: InspectData,
}

impl SystemShutdownHandler {
    /// Start and publish the fuchsia.hardware.power.statecontrol.Admin service
    fn publish_fidl_service<'a, 'b>(
        self: Rc<Self>,
        service_fs: &'a mut ServiceFs<ServiceObjLocal<'b, ()>>,
    ) {
        service_fs.dir("svc").add_fidl_service(move |stream| {
            self.clone().handle_new_service_connection(stream);
        });
    }

    /// Called each time a client connects. For each client, a future is created to handle the
    /// request stream.
    fn handle_new_service_connection(
        self: Rc<Self>,
        mut stream: fpowercontrol::AdminRequestStream,
    ) {
        fuchsia_trace::instant!(
            "power_manager",
            "SystemShutdownHandler::handle_new_service_connection",
            fuchsia_trace::Scope::Thread
        );
        fasync::Task::local(
            async move {
                while let Some(req) = stream.try_next().await? {
                    match req {
                        fpowercontrol::AdminRequest::PowerFullyOn { responder } => {
                            let _ = responder.send(&mut Err(zx::Status::NOT_SUPPORTED.into_raw()));
                        }
                        fpowercontrol::AdminRequest::Reboot { reason, responder } => {
                            let result =
                                self.handle_shutdown(ShutdownRequest::Reboot(reason)).await;
                            let _ = responder.send(&mut result.map_err(|e| e.into_raw()));
                        }
                        fpowercontrol::AdminRequest::RebootToBootloader { responder } => {
                            let result =
                                self.handle_shutdown(ShutdownRequest::RebootBootloader).await;
                            let _ = responder.send(&mut result.map_err(|e| e.into_raw()));
                        }
                        fpowercontrol::AdminRequest::RebootToRecovery { responder } => {
                            let result =
                                self.handle_shutdown(ShutdownRequest::RebootRecovery).await;
                            let _ = responder.send(&mut result.map_err(|e| e.into_raw()));
                        }
                        fpowercontrol::AdminRequest::Poweroff { responder } => {
                            let result = self.handle_shutdown(ShutdownRequest::PowerOff).await;
                            let _ = responder.send(&mut result.map_err(|e| e.into_raw()));
                        }
                        fpowercontrol::AdminRequest::Mexec { responder } => {
                            let _ = responder.send(&mut Err(zx::Status::NOT_SUPPORTED.into_raw()));
                        }
                        fpowercontrol::AdminRequest::SuspendToRam { responder } => {
                            let _ = responder.send(&mut Err(zx::Status::NOT_SUPPORTED.into_raw()));
                        }
                    }
                }
                Ok(())
            }
            .unwrap_or_else(|e| match e {
                // TODO(pshickel): The shutdown-shim component sends us a garbage FIDL call to check
                // if we're alive before forwarding shutdown commands. We should avoid error logging
                // for this specific error type to avoid potential confusion.
                fidl::Error::OutOfRange => {}
                e => error!("{:?}", e),
            }),
        )
        .detach();
    }

    /// Called each time a client calls the fuchsia.hardware.power.statecontrol.Admin API to
    /// initiate a system state transition. If the function is called while a shutdown is already in
    /// progress, then an error is returned. This is the only scenario where the function will
    /// return. In all other cases, the function does not return.
    async fn handle_shutdown(&self, request: ShutdownRequest) -> Result<(), zx_status> {
        fuchsia_trace::instant!(
            "power_manager",
            "SystemShutdownHandler::handle_shutdown",
            fuchsia_trace::Scope::Thread,
            "request" => format!("{:?}", request).as_str()
        );

        // Return if shutdown is already pending
        if self.shutdown_pending.replace(true) == true {
            return Err(zx_status::ALREADY_EXISTS);
        }

        info!("System shutdown ({:?})", request);
        self.inspect.log_shutdown_request(&request);

        // If we have one, notify the ShutdownWatcher node of the incoming shutdown request.
        // Since the call is blocking, the node could choose to delay shutdown if it likes.
        if let Some(watcher_node) = &self.shutdown_watcher {
            let _ = self.send_message(watcher_node, &Message::SystemShutdown(request)).await;
        }

        // Handle the shutdown using a timeout if one is present in the config
        let result = if let Some(timeout) = self.shutdown_timeout {
            self.shutdown_with_timeout(request, timeout).await
        } else {
            self.shutdown(request).await
        };

        // If the result is an error, either by underlying API failure or by timeout, then force a
        // shutdown using the configured force_shutdown_func
        if result.is_err() {
            self.inspect.force_shutdown_attempted.set(true);
            (self.force_shutdown_func)();
        }

        Ok(())
    }

    /// Wraps the node's `shutdown` function with a timeout value. If the `shutdown` call has not
    /// returned within the specified timeout, an error is returned. In the event of a timeout, the
    /// underlying channel that encountered the timeout may encounter issues with subsequent
    /// transactions (fxbug.dev/53760). In this case, that means either the channel used by the
    /// `driver_mgr_handler` node or the `component_mgr_proxy` channel encountered the timeout. In
    /// all likelihood, because Driver Manager will not be doing any meaningful work in response to
    /// this FIDL call, we can presume that Component Manager, which will be performing a
    /// significant amount of work, is the channel that encountered the timeout. Therefore, care
    /// should be taken to avoid reusing the `component_mgr_proxy` channel in the event of a
    /// shutdown timeout. Currently this is not a problem because in the event of a timeout, we will
    /// force a system shutdown by other means.
    async fn shutdown_with_timeout(
        &self,
        request: ShutdownRequest,
        timeout: Seconds,
    ) -> Result<(), Error> {
        let deadline = zx::Duration::from_seconds(timeout.0 as i64).after_now();
        self.shutdown(request).on_timeout(deadline, || Err(format_err!("Shutdown timed out"))).await
    }

    /// Shut down the system into the specified state. The function works as follows:
    ///     1. Update the Driver Manager's termination state to match the requested shutdown state
    ///     2. Issue a shutdown to the Component Manager
    ///     3. Once the Component Manager shutdown process reaches the Driver Manager component,
    ///        the system will be put into the state that is specified by the termination state
    async fn shutdown(&self, request: ShutdownRequest) -> Result<(), Error> {
        self.send_message(
            &self.driver_mgr_handler,
            &Message::SetTerminationSystemState(request.into()),
        )
        .await?;
        self.component_mgr_proxy.shutdown().await?;
        Ok(())
    }

    /// Handle a SystemShutdown message which is a request to shut down the system from within the
    /// PowerManager itself.
    async fn handle_system_shutdown_message(
        &self,
        request: ShutdownRequest,
    ) -> Result<MessageReturn, PowerManagerError> {
        match self.handle_shutdown(request).await {
            Ok(()) => Ok(MessageReturn::SystemShutdown),
            Err(zx_status::ALREADY_EXISTS) => {
                Err(PowerManagerError::Busy("Shutdown already in progress".to_string()))
            }
            Err(e) => Err(PowerManagerError::GenericError(format_err!("{}", e))),
        }
    }
}

/// Forcibly shuts down the system. The function works by exiting the power_manager process. Since
/// the power_manager is marked as a critical process to the root job, once the power_manager exits
/// the root job will also exit, and the system will reboot.
pub fn force_shutdown() {
    info!("Force shutdown requested");
    std::process::exit(1);
}

#[async_trait(?Send)]
impl Node for SystemShutdownHandler {
    fn name(&self) -> String {
        "SystemShutdownHandler".to_string()
    }

    async fn handle_message(&self, msg: &Message) -> Result<MessageReturn, PowerManagerError> {
        match msg {
            Message::SystemShutdown(request) => self.handle_system_shutdown_message(*request).await,
            _ => Err(PowerManagerError::Unsupported),
        }
    }
}

struct InspectData {
    // Nodes
    root_node: inspect::Node,

    // Properties
    shutdown_request: inspect::StringProperty,
    force_shutdown_attempted: inspect::BoolProperty,
}

impl InspectData {
    fn new(parent: &inspect::Node, name: String) -> Self {
        let root_node = parent.create_child(name);
        Self {
            shutdown_request: root_node.create_string("shutdown_request", "None"),
            force_shutdown_attempted: root_node.create_bool("force_shutdown_attempted", false),
            root_node,
        }
    }

    /// Populates any configuration data from the SystemShutdownHandler into an Inspect config node.
    fn set_config(&self, handler: &SystemShutdownHandler) {
        let config_node = self.root_node.create_child("config");
        config_node.record_uint(
            "shutdown_timeout (s)",
            handler.shutdown_timeout.unwrap_or(Seconds(0.0)).0 as u64,
        );
        self.root_node.record(config_node);
    }

    /// Updates the `shutdown_request` property according to the provided request.
    fn log_shutdown_request(&self, request: &ShutdownRequest) {
        self.shutdown_request.set(format!("{:?}", request).as_str());
    }
}

#[cfg(test)]
pub mod tests {
    use super::*;
    use crate::shutdown_request::RebootReason;
    use crate::test::mock_node::{create_dummy_node, MessageMatcher, MockNodeMaker};
    use crate::{msg_eq, msg_ok_return};
    use inspect::assert_inspect_tree;
    use matches::assert_matches;

    pub fn setup_test_node(shutdown_function: impl Fn() + 'static) -> Rc<SystemShutdownHandler> {
        SystemShutdownHandlerBuilder::new(create_dummy_node())
            .with_force_shutdown_function(Box::new(shutdown_function))
            .with_component_mgr_proxy(setup_fake_component_mgr_service(|| {}))
            .build()
            .unwrap()
    }

    /// Create a fake SystemController service proxy that responds to Shutdown requests by calling
    /// the provided closure.
    fn setup_fake_component_mgr_service(
        mut shutdown_function: impl FnMut() + 'static,
    ) -> fsys::SystemControllerProxy {
        let (proxy, mut stream) =
            fidl::endpoints::create_proxy_and_stream::<fsys::SystemControllerMarker>().unwrap();
        fasync::Task::local(async move {
            while let Ok(req) = stream.try_next().await {
                match req {
                    Some(fsys::SystemControllerRequest::Shutdown { responder }) => {
                        shutdown_function();
                        let _ = responder.send();
                    }
                    e => panic!("Unexpected request: {:?}", e),
                }
            }
        })
        .detach();

        proxy
    }

    /// Tests that well-formed configuration JSON does not panic the `new_from_json` function.
    #[fasync::run_singlethreaded(test)]
    async fn test_new_from_json() {
        let json_data = json::json!({
            "type": "SystemShutdownHandler",
            "name": "system_shutdown_handler",
            "config": {
                "component_manager_path": "/svc/fake"
            },
            "dependencies": {
                "driver_manager_handler_node": "dev_mgr"
            }
        });

        let mut nodes: HashMap<String, Rc<dyn Node>> = HashMap::new();
        nodes.insert("dev_mgr".to_string(), create_dummy_node());

        let _ = SystemShutdownHandlerBuilder::new_from_json(
            json_data,
            &nodes,
            &mut ServiceFs::new_local(),
        );
    }

    /// Tests for the presence and correctness of inspect data
    #[fasync::run_singlethreaded(test)]
    async fn test_inspect_data() {
        let inspector = inspect::Inspector::new();
        let node = SystemShutdownHandlerBuilder::new(create_dummy_node())
            .with_component_mgr_proxy(setup_fake_component_mgr_service(|| {}))
            .with_inspect_root(inspector.root())
            .with_force_shutdown_function(Box::new(|| {}))
            .with_shutdown_timeout(Seconds(100.0))
            .build()
            .unwrap();

        // Issue a shutdown call that will fail (because the DriverManager dummy node will respond
        // to SetTerminationSystemState with an error), which causes a force shutdown to be issued.
        // This gives us something interesting to verify in Inspect.
        let _ = node.handle_shutdown(ShutdownRequest::Reboot(RebootReason::HighTemperature)).await;

        assert_inspect_tree!(
            inspector,
            root: {
                SystemShutdownHandler: {
                    config: {
                        "shutdown_timeout (s)": 100u64
                    },
                    shutdown_request: "Reboot(HighTemperature)",
                    force_shutdown_attempted: true
                }
            }
        );
    }

    /// Tests that the `shutdown` function correctly sets the corresponding termination state on the
    /// Driver Manager and calls the Component Manager shutdown API.
    #[fasync::run_singlethreaded(test)]
    async fn test_shutdown() {
        let mut mock_maker = MockNodeMaker::new();

        // The test will call `shutdown` with each of these shutdown requests
        let shutdown_requests = vec![
            ShutdownRequest::Reboot(RebootReason::UserRequest),
            ShutdownRequest::RebootBootloader,
            ShutdownRequest::RebootRecovery,
            ShutdownRequest::PowerOff,
        ];

        // At the end of the test, verify the Component Manager's received shutdown count (expected
        // to be equal to the number of entries in the system_power_states vector)
        let shutdown_count = Rc::new(Cell::new(0));
        let shutdown_count_clone = shutdown_count.clone();

        // Create the mock Driver Manager node that expects to receive the SetTerminationSystemState
        // message for each state in `system_power_states`
        let driver_mgr_node = mock_maker.make(
            "DriverMgrNode",
            shutdown_requests
                .iter()
                .map(|request| {
                    (
                        msg_eq!(SetTerminationSystemState((*request).into())),
                        msg_ok_return!(SetTerminationSystemState),
                    )
                })
                .collect(),
        );

        // Create the node with a special Component Manager proxy
        let node = SystemShutdownHandlerBuilder::new(driver_mgr_node)
            .with_component_mgr_proxy(setup_fake_component_mgr_service(move || {
                shutdown_count_clone.set(shutdown_count_clone.get() + 1);
            }))
            .build()
            .unwrap();

        // Call `suspend` for each power state. The mock Driver Manager node verifies that the
        // SetTerminationSystemState messages are sent as expected.
        for request in &shutdown_requests {
            let _ = node.shutdown(*request).await;
        }

        // Verify the Component Manager shutdown was called for each shutdown call
        assert_eq!(shutdown_count.get(), shutdown_requests.len());
    }

    /// Tests that the shutdown timer works as expected by returning with an error after the
    /// expected timeout period.
    #[test]
    fn test_shutdown_timeout() {
        let mut mock_maker = MockNodeMaker::new();

        // Need to use an Executor with fake time to test the timeout value
        let mut exec = fasync::Executor::new_with_fake_time().unwrap();
        exec.set_fake_time(Seconds(0.0).into());

        // Arbitrary shutdown request to be used in the test
        let shutdown_request = ShutdownRequest::PowerOff;

        // Arbitrary timeout value to be used in the test
        let timeout = Seconds(10.0);

        // Don't use `setup_fake_component_mgr_service` here because we want a stream object that
        // doesn't respond to the request. This way we can properly exercise the timeout path.
        let (proxy, _stream) =
            fidl::endpoints::create_proxy_and_stream::<fsys::SystemControllerMarker>().unwrap();

        // Create the SystemShutdownHandler node
        let node = SystemShutdownHandlerBuilder::new(mock_maker.make(
            "DriverMgrNode",
            vec![(
                msg_eq!(SetTerminationSystemState(shutdown_request.into())),
                msg_ok_return!(SetTerminationSystemState),
            )],
        ))
        .with_component_mgr_proxy(proxy)
        .build()
        .unwrap();

        // Future that attempts a suspend with a timeout
        let mut shutdown_future = Box::pin(node.shutdown_with_timeout(shutdown_request, timeout));

        // Run the future until it stalls. In this case, the stall will happen because the fake
        // Component Manager proxy doesn't respond to the shutdown request.
        assert!(exec.run_until_stalled(&mut shutdown_future).is_pending());

        // Wake the timer and verify the timer was scheduled to fire at the expected time
        assert_eq!(exec.wake_next_timer(), Some(timeout.into()));

        // Run the future again. This time it should complete with an error (due to the timeout)
        assert_matches!(
            exec.run_until_stalled(&mut shutdown_future),
            futures::task::Poll::Ready(Err(_))
        );
    }

    /// Tests that a second shutdown request will fail with an error if a prior request is already
    /// in progress.
    #[test]
    fn test_ignore_second_shutdown() {
        let mut mock_maker = MockNodeMaker::new();
        let mut exec = fasync::Executor::new().unwrap();

        // Arbitrary shutdown request to be used in the test
        let shutdown_request = ShutdownRequest::PowerOff;

        // Don't use `setup_fake_component_mgr_service` here because we want a stream object that
        // doesn't respond to the request. This way we can properly exercise the timeout path.
        let (proxy, _stream) =
            fidl::endpoints::create_proxy_and_stream::<fsys::SystemControllerMarker>().unwrap();
        let node = SystemShutdownHandlerBuilder::new(mock_maker.make(
            "DriverMgrNode",
            vec![(
                msg_eq!(SetTerminationSystemState(shutdown_request.into())),
                msg_ok_return!(SetTerminationSystemState),
            )],
        ))
        .with_component_mgr_proxy(proxy)
        .build()
        .unwrap();

        // Run the first shutdown request. This is expected to stall because the fake Component
        // Manager proxy will not be responding to the request.
        assert!(exec
            .run_until_stalled(&mut Box::pin(node.handle_shutdown(shutdown_request)))
            .is_pending());

        // Run a second request and verify it returns with the expected error
        assert_matches!(
            exec.run_until_stalled(&mut Box::pin(node.handle_shutdown(shutdown_request))),
            futures::task::Poll::Ready(Err(zx_status::ALREADY_EXISTS))
        );
    }

    /// Tests that if an orderly shutdown request fails, the forced shutdown method is called.
    #[fasync::run_singlethreaded(test)]
    async fn test_force_shutdown() {
        let force_shutdown = Rc::new(Cell::new(false));
        let force_shutdown_clone = force_shutdown.clone();
        let force_shutdown_func = Box::new(move || {
            force_shutdown_clone.set(true);
        });

        let node = SystemShutdownHandlerBuilder::new(create_dummy_node())
            .with_component_mgr_proxy(setup_fake_component_mgr_service(|| {}))
            .with_force_shutdown_function(force_shutdown_func)
            .build()
            .unwrap();

        // Call the normal shutdown function. The orderly shutdown will fail because the
        // DriverManager dummy node will respond to the SetTerminationSystemState message with an
        // error. When the orderly shutdown fails, the forced shutdown method will be called.
        let _ = node.handle_shutdown(ShutdownRequest::PowerOff).await;
        assert_eq!(force_shutdown.get(), true);
    }

    /// Tests that when the node is sent a shutdown request and there is a ShutdownWatcher node
    /// present, then the watcher node is notified of the shutdown request.
    #[fasync::run_singlethreaded(test)]
    async fn test_watcher_notify() {
        let mut mock_maker = MockNodeMaker::new();

        // Choose an arbitrary shutdown request for the test
        let shutdown_request = ShutdownRequest::Reboot(RebootReason::HighTemperature);

        // A mock DriverManagerHandler node that expects the SetTerminationSystemState message
        // corresponding to the above shutdown_request
        let driver_mgr_node = mock_maker.make(
            "DriverManagerHandler",
            vec![(
                msg_eq!(SetTerminationSystemState(shutdown_request.into())),
                msg_ok_return!(SetTerminationSystemState),
            )],
        );

        // A mock ShutdownWatcher node that expects the SystemShutdown message containing the above
        // shutdown_request
        let shutdown_watcher = mock_maker.make(
            "ShutdownWatcher",
            vec![(msg_eq!(SystemShutdown(shutdown_request)), msg_ok_return!(SystemShutdown))],
        );

        // Create the SystemShutdownHandler node and send the shutdown request
        let node = SystemShutdownHandlerBuilder::new(driver_mgr_node)
            .with_component_mgr_proxy(setup_fake_component_mgr_service(|| {}))
            .with_shutdown_watcher(shutdown_watcher)
            .build()
            .unwrap();
        assert!(node.handle_shutdown(shutdown_request).await.is_ok());

        // When the test exits, the mock nodes' drop methods verify that the expected messages
        // were received
    }

    /// Tests that the expected fuchsia.hardware.power.statecontrol.Admin methods return
    /// NOT_SUPPORTED as intended.
    #[fasync::run_singlethreaded(test)]
    async fn test_unsupported_shutdown_methods() {
        let (proxy, stream) =
            fidl::endpoints::create_proxy_and_stream::<fpowercontrol::AdminMarker>().unwrap();
        let node = SystemShutdownHandlerBuilder::new(create_dummy_node())
            .with_component_mgr_proxy(setup_fake_component_mgr_service(|| {}))
            .build()
            .unwrap();

        node.handle_new_service_connection(stream);

        assert_eq!(proxy.mexec().await.unwrap(), Err(zx::Status::NOT_SUPPORTED.into_raw()));
        assert_eq!(
            proxy.power_fully_on().await.unwrap(),
            Err(zx::Status::NOT_SUPPORTED.into_raw())
        );
        assert_eq!(
            proxy.suspend_to_ram().await.unwrap(),
            Err(zx::Status::NOT_SUPPORTED.into_raw())
        );
    }
}