| // Copyright 2022 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 <fidl/fuchsia.driver.framework/cpp/fidl.h> | |
| #include <fidl/fuchsia.runtime.test/cpp/driver/fidl.h> | |
| #include <fidl/fuchsia.runtime.test/cpp/fidl.h> | |
| #include <lib/async/cpp/executor.h> | |
| #include <lib/driver/component/cpp/driver_base.h> | |
| #include <lib/driver/component/cpp/driver_base2.h> | |
| #include <lib/driver/component/cpp/driver_export2.h> | |
| #include <lib/driver/incoming/cpp/namespace.h> | |
| #include <lib/driver/logging/cpp/logger.h> | |
| #include <lib/fdf/cpp/arena.h> | |
| #include <lib/fdf/cpp/channel.h> | |
| #include <lib/fdf/cpp/protocol.h> | |
| #include <lib/fpromise/bridge.h> | |
| #include <lib/fpromise/scope.h> | |
| #include "src/lib/fidl/contrib/fpromise/client.h" | |
| namespace fdf { | |
| using namespace fuchsia_driver_framework; | |
| } // namespace fdf | |
| namespace ft = fuchsia_runtime_test; | |
| using fpromise::error; | |
| using fpromise::ok; | |
| using fpromise::promise; | |
| using fpromise::result; | |
| namespace { | |
| class LeafDriver : public fdf::DriverBase2 { | |
| public: | |
| LeafDriver() : DriverBase2("leaf") {} | |
| zx::result<> Start(fdf::DriverContext context) override { | |
| executor_.emplace(dispatcher()); | |
| node_ = fidl::WireSharedClient(take_node(), dispatcher()); | |
| auto setter_client = context.incoming().Connect<ft::Service::Setter>(); | |
| if (setter_client.is_error()) { | |
| return setter_client.take_error(); | |
| } | |
| setter_.Bind(*std::move(setter_client), driver_dispatcher()->get()); | |
| auto getter_client = context.incoming().Connect<ft::Service::Getter>(); | |
| if (getter_client.is_error()) { | |
| return getter_client.take_error(); | |
| } | |
| getter_.Bind(*std::move(getter_client), driver_dispatcher()->get()); | |
| auto waiter_client = context.incoming().Connect<ft::Waiter>(); | |
| if (waiter_client.is_error()) { | |
| return waiter_client.take_error(); | |
| } | |
| waiter_.Bind(*std::move(waiter_client), dispatcher()); | |
| auto task = CallSetter() | |
| .and_then(fit::bind_member(this, &LeafDriver::CallGetter)) | |
| .and_then(fit::bind_member(this, &LeafDriver::CallAck)) | |
| .or_else(fit::bind_member(this, &LeafDriver::UnbindNode)) | |
| .wrap_with(scope_); | |
| executor_->schedule_task(std::move(task)); | |
| return zx::ok(); | |
| } | |
| private: | |
| // Magic number that we will set and retrieve from our parent via driver runtime protocols. | |
| static constexpr const uint32_t kMagic = 123456; | |
| fpromise::promise<void, zx_status_t> CallSetter() { | |
| fdf::Arena arena('TEST'); | |
| ft::WrappedValue wrapped_value; | |
| wrapped_value.value() = kMagic; | |
| auto arg = fidl::ToWire(arena, wrapped_value); | |
| fpromise::bridge<void, zx_status_t> bridge; | |
| auto callback = [completer = std::move(bridge.completer)]( | |
| fdf::WireUnownedResult<ft::Setter::Set>& result) mutable { | |
| if (!result.ok()) { | |
| completer.complete_error(result.status()); | |
| return; | |
| } | |
| completer.complete_ok(); | |
| }; | |
| setter_.buffer(arena)->Set(arg).ThenExactlyOnce(std::move(callback)); | |
| return bridge.consumer.promise(); | |
| } | |
| fpromise::promise<void, zx_status_t> CallGetter() { | |
| return fidl_fpromise::as_promise(getter_->Get()) | |
| .then([&](fpromise::result<ft::GetterGetResponse, fidl::ErrorsIn<ft::Getter::Get>>& result) | |
| -> fpromise::promise<void, zx_status_t> { | |
| if (result.is_error()) { | |
| zx_status_t status = result.error().is_domain_error() | |
| ? result.error().domain_error() | |
| : result.error().framework_error().status(); | |
| return fpromise::make_error_promise(status); | |
| } | |
| if (result.value() != kMagic) { | |
| return fpromise::make_error_promise(ZX_ERR_BAD_STATE); | |
| } | |
| return fpromise::make_result_promise<void, zx_status_t>(fpromise::ok()); | |
| }); | |
| } | |
| result<void, zx_status_t> CallAck() { | |
| [[maybe_unused]] auto result = waiter_->Ack(); | |
| return ok(); | |
| } | |
| result<> UnbindNode(const zx_status_t& status) { | |
| fdf::error("Failed to start leaf driver: {}", zx_status_get_string(status)); | |
| node_.AsyncTeardown(); | |
| return ok(); | |
| } | |
| std::optional<async::Executor> executor_; | |
| fidl::WireSharedClient<fdf::Node> node_; | |
| // This is specifically a |WireClient| so we can test using |fdf::Arena|. | |
| fdf::WireClient<ft::Setter> setter_; | |
| fdf::Client<ft::Getter> getter_; | |
| fidl::Client<ft::Waiter> waiter_; | |
| // NOTE: Must be the last member. | |
| fpromise::scope scope_; | |
| }; | |
| } // namespace | |
| FUCHSIA_DRIVER_EXPORT2(LeafDriver); |