| // Copyright 2019 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // See help usage message in main() for basic description. |
| |
| #include <cstdlib> |
| #include <iostream> |
| #include <memory> |
| #include <string> |
| |
| #include <brillo/flag_helper.h> |
| |
| #include "diagnostics/dpsl/public/dpsl_global_context.h" |
| #include "diagnostics/dpsl/public/dpsl_rpc_handler.h" |
| #include "diagnostics/dpsl/public/dpsl_rpc_server.h" |
| #include "diagnostics/dpsl/public/dpsl_thread_context.h" |
| #include "diagnostics/dpsl/test_utils/common.h" |
| |
| #include "wilco_dtc.pb.h" // NOLINT(build/include_directory) |
| #include "wilco_dtc_supportd.pb.h" // NOLINT(build/include_directory) |
| |
| namespace diagnostics { |
| namespace { |
| |
| class DpslTestListener final : public DpslRpcHandler { |
| public: |
| DpslTestListener( |
| std::unique_ptr<grpc_api::HandleMessageFromUiResponse> ui_response) { |
| ui_response_ = std::move(ui_response); |
| } |
| |
| // DpslRpcHandler overrides: |
| void HandleMessageFromUi( |
| std::unique_ptr<grpc_api::HandleMessageFromUiRequest> request, |
| HandleMessageFromUiCallback callback) override { |
| test_utils::PrintProto(*request); |
| // Note: every incoming RPC must be answered. |
| callback( |
| std::make_unique<grpc_api::HandleMessageFromUiResponse>(*ui_response_)); |
| }; |
| |
| void HandleEcNotification( |
| std::unique_ptr<grpc_api::HandleEcNotificationRequest> request, |
| HandleEcNotificationCallback callback) override { |
| test_utils::PrintProto(*request); |
| // Note: every incoming RPC must be answered. |
| callback(std::make_unique<grpc_api::HandleEcNotificationResponse>()); |
| }; |
| |
| void HandlePowerNotification( |
| std::unique_ptr<grpc_api::HandlePowerNotificationRequest> request, |
| HandlePowerNotificationCallback callback) override { |
| test_utils::PrintProto(*request); |
| // Note: every incoming RPC must be answered. |
| callback(std::make_unique<grpc_api::HandlePowerNotificationResponse>()); |
| }; |
| |
| void HandleConfigurationDataChanged( |
| std::unique_ptr<grpc_api::HandleConfigurationDataChangedRequest> request, |
| HandleConfigurationDataChangedCallback callback) override { |
| test_utils::PrintProto(*request); |
| // Note: every incoming RPC must be answered. |
| callback( |
| std::make_unique<grpc_api::HandleConfigurationDataChangedResponse>()); |
| }; |
| |
| void HandleBluetoothDataChanged( |
| std::unique_ptr<grpc_api::HandleBluetoothDataChangedRequest> request, |
| HandleBluetoothDataChangedCallback callback) override { |
| test_utils::PrintProto(*request); |
| // Note: every incoming RPC must be answered. |
| callback(std::make_unique<grpc_api::HandleBluetoothDataChangedResponse>()); |
| }; |
| |
| private: |
| std::unique_ptr<grpc_api::HandleMessageFromUiResponse> ui_response_; |
| }; |
| |
| } // namespace |
| } // namespace diagnostics |
| |
| int main(int argc, char** argv) { |
| DEFINE_string(ui_response_body, "", |
| "optional JSON-formatted body of proto to send as the response " |
| "to HandleMessageFromUi"); |
| constexpr char kUsageMessage[] = |
| R"(DPSL Listener Utility |
| Command line utility to test DPSL communication into and out of a VM. The |
| utility blocks indefinitely, monitoring and printing any incoming gRPC requests |
| from wilco_dtc_supportd. The request is printed as JSON, so you can see both the |
| name and the actual content of the proto. |
| |
| EXAMPLE USAGE |
| (VM)$ diagnostics_dpsl_test_listener \ |
| --ui_response_body='{"response_json_message": "{test: 1}"}' |
| ...THEN YOU FORCE THE EC TO GENERATE AN EVENT... |
| { |
| "body": { |
| "type": 19, |
| "payload":"AAABAAIAAwAEAAUA" |
| }, |
| "name": "HandleEcNotificationRequest" |
| })"; |
| brillo::FlagHelper::Init(argc, argv, kUsageMessage); |
| |
| std::unique_ptr<diagnostics::grpc_api::HandleMessageFromUiResponse> |
| ui_response; |
| if (!FLAGS_ui_response_body.empty()) { |
| ui_response = diagnostics::test_utils::JsonToProto< |
| diagnostics::grpc_api::HandleMessageFromUiResponse>( |
| FLAGS_ui_response_body); |
| |
| if (!ui_response) { |
| std::cerr << "Failed to parse ui_response_body\n"; |
| return EXIT_FAILURE; |
| } |
| } else { |
| ui_response = |
| std::make_unique<diagnostics::grpc_api::HandleMessageFromUiResponse>(); |
| } |
| |
| auto global_context = diagnostics::DpslGlobalContext::Create(); |
| auto thread_context = |
| diagnostics::DpslThreadContext::Create(global_context.get()); |
| diagnostics::DpslTestListener listener(std::move(ui_response)); |
| auto rpc_server = diagnostics::DpslRpcServer::Create( |
| thread_context.get(), &listener, |
| diagnostics::DpslRpcServer::GrpcServerUri::kUiMessageReceiverVmVsock); |
| if (!rpc_server) { |
| std::cerr << "Failed to create DpslRpcServer\n"; |
| return EXIT_FAILURE; |
| } |
| |
| // This blocks forever, responding to any incoming gRPC requests. |
| thread_context->RunEventLoop(); |
| |
| return EXIT_SUCCESS; |
| } |