blob: 7cb0a3e9cfe18eff612e9d801bf9f4be140503ce [file]
// Copyright 2023 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.
#include "src/developer/forensics/feedback/stop_signals.h"
#include <fidl/fuchsia.hardware.power.statecontrol/cpp/fidl.h>
#include <fidl/fuchsia.hardware.power.statecontrol/cpp/hlcpp_conversion.h>
#include <fidl/fuchsia.process.lifecycle/cpp/fidl.h>
#include <lib/fit/defer.h>
#include <lib/fit/function.h>
#include <lib/fpromise/bridge.h>
#include <lib/fpromise/promise.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/zx/channel.h>
#include <memory>
#include "src/developer/forensics/utils/errors.h"
namespace forensics::feedback {
namespace {
// Handles receiving the signal the component should stop and converting into a
// `LifecycleStopSignal`.
class LifecycleServer : public fidl::Server<fuchsia_process_lifecycle::Lifecycle> {
public:
LifecycleServer(async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_process_lifecycle::Lifecycle> server_end,
fpromise::completer<LifecycleStopSignal, Error> completer);
void Stop(StopCompleter::Sync& completer) override;
private:
std::unique_ptr<fidl::ServerBinding<fuchsia_process_lifecycle::Lifecycle>> binding_;
fpromise::completer<LifecycleStopSignal, Error> completer_;
};
LifecycleServer::LifecycleServer(async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_process_lifecycle::Lifecycle> server_end,
fpromise::completer<LifecycleStopSignal, Error> completer)
: binding_(std::make_unique<fidl::ServerBinding<fuchsia_process_lifecycle::Lifecycle>>(
dispatcher, std::move(server_end), this,
[this](const fidl::UnbindInfo info) {
if (!completer_) {
return;
}
FX_PLOGS(WARNING, info.status()) << "Lost connection to lifecycle client";
completer_.complete_error(Error::kConnectionError);
})),
completer_(std::move(completer)) {}
void LifecycleServer::Stop(StopCompleter::Sync& completer) {
if (completer_) {
// Move `binding_` to avoid breaking references to internal member variables.
auto cb = fit::defer([b = std::move(binding_)]() mutable { b.reset(); });
completer_.complete_ok(LifecycleStopSignal([cb = std::move(cb)]() mutable { cb.call(); }));
}
}
} // namespace
LifecycleStopSignal::LifecycleStopSignal(fit::callback<void(void)> callback)
: callback_(std::move(callback)) {
FX_CHECK(callback_ != nullptr);
}
fpromise::promise<LifecycleStopSignal, Error> WaitForLifecycleStop(
async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_process_lifecycle::Lifecycle> server_end) {
if (!server_end.is_valid()) {
return fpromise::make_result_promise<LifecycleStopSignal, Error>(
fpromise::error(Error::kBadValue));
}
fpromise::bridge<LifecycleStopSignal, Error> bridge;
auto lifecycle = std::make_unique<LifecycleServer>(dispatcher, std::move(server_end),
std::move(bridge.completer));
return bridge.consumer.promise_or(fpromise::error(Error::kLogicError))
.then([l = std::move(lifecycle)](fpromise::result<LifecycleStopSignal, Error>& result) {
return std::move(result);
});
}
namespace {
// Handles receiving the reason a shutdown is expected to occur and converting into a
// `GracefulShutdownInfoSignal`.
class ShutdownWatcherServer
: public fidl::Server<fuchsia_hardware_power_statecontrol::ShutdownWatcher> {
public:
ShutdownWatcherServer(
async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_hardware_power_statecontrol::ShutdownWatcher> server_end,
fpromise::completer<GracefulShutdownInfoSignal, Error> completer);
void OnShutdown(OnShutdownRequest& request, OnShutdownCompleter::Sync& completer) override;
void handle_unknown_method(
fidl::UnknownMethodMetadata<fuchsia_hardware_power_statecontrol::ShutdownWatcher> metadata,
fidl::UnknownMethodCompleter::Sync& completer) override {
FX_LOGS(WARNING) << "Received an unknown method with ordinal: " << metadata.method_ordinal;
}
private:
std::unique_ptr<fidl::ServerBinding<fuchsia_hardware_power_statecontrol::ShutdownWatcher>>
binding_;
fpromise::completer<GracefulShutdownInfoSignal, Error> completer_;
};
ShutdownWatcherServer::ShutdownWatcherServer(
async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_hardware_power_statecontrol::ShutdownWatcher> server_end,
fpromise::completer<GracefulShutdownInfoSignal, Error> completer)
: binding_(std::make_unique<
fidl::ServerBinding<fuchsia_hardware_power_statecontrol::ShutdownWatcher>>(
dispatcher, std::move(server_end), this,
[this](const fidl::UnbindInfo info) {
if (!completer_) {
return;
}
FX_PLOGS(WARNING, info.status())
<< "Lost connection to shutdown watcher client, won't reconnect";
completer_.complete_error(Error::kConnectionError);
})),
completer_(std::move(completer)) {}
void ShutdownWatcherServer::OnShutdown(OnShutdownRequest& request,
OnShutdownCompleter::Sync& completer) {
if (!completer_) {
completer.Reply();
return;
}
if (!request.options().action().has_value()) {
FX_LOGS(WARNING) << "Received shutdown signal without an action";
completer.Reply();
return;
}
// Move `binding_` to avoid breaking references to internal member variables.
auto cb = fit::defer([completer = completer.ToAsync(), b = std::move(binding_)]() mutable {
completer.Reply();
b.reset();
});
const fuchsia::hardware::power::statecontrol::ShutdownOptions hlcpp_options =
fidl::NaturalToHLCPP(request.options());
completer_.complete_ok(GracefulShutdownInfoSignal(ToGracefulShutdownAction(hlcpp_options),
ToGracefulShutdownReasons(hlcpp_options),
[cb = std::move(cb)]() mutable { cb.call(); }));
}
} // namespace
GracefulShutdownInfoSignal::GracefulShutdownInfoSignal(GracefulShutdownAction action,
std::vector<GracefulShutdownReason> reasons,
fit::callback<void(void)> callback)
: action_(action), reasons_(std::move(reasons)), callback_(std::move(callback)) {
FX_CHECK(callback_ != nullptr);
}
fpromise::promise<GracefulShutdownInfoSignal, Error> WaitForShutdownInfo(
async_dispatcher_t* dispatcher,
fidl::ServerEnd<fuchsia_hardware_power_statecontrol::ShutdownWatcher> server_end) {
if (!server_end.is_valid()) {
return fpromise::make_result_promise<GracefulShutdownInfoSignal, Error>(
fpromise::error(Error::kBadValue));
}
fpromise::bridge<GracefulShutdownInfoSignal, Error> bridge;
auto watcher = std::make_unique<ShutdownWatcherServer>(dispatcher, std::move(server_end),
std::move(bridge.completer));
return bridge.consumer.promise_or(fpromise::error(Error::kLogicError))
.then([w = std::move(watcher)](fpromise::result<GracefulShutdownInfoSignal, Error>& result) {
return std::move(result);
});
}
} // namespace forensics::feedback