pw_rpc: Remove ChannelOutput arg for ProcessPacket
The original intent of the ChannelOutput-accepting variant
of ProcessPacket was to support dynamic assignment of
channels, but that is solved via a different API now.
The interface is currently used to report errors, but those
are also available via the return status.
Change-Id: Id829f2c365f8e9dc2592fe5dda97bb652a6c46fc
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/107335
Reviewed-by: Wyatt Hepler <hepler@google.com>
Commit-Queue: Taylor Cramer <cramertj@google.com>
diff --git a/pw_hdlc/hdlc_sys_io_system_server.cc b/pw_hdlc/hdlc_sys_io_system_server.cc
index 74934a3..c2af547 100644
--- a/pw_hdlc/hdlc_sys_io_system_server.cc
+++ b/pw_hdlc/hdlc_sys_io_system_server.cc
@@ -69,7 +69,7 @@
if (auto result = decoder.Process(byte); result.ok()) {
hdlc::Frame& frame = result.value();
if (frame.address() == hdlc::kDefaultRpcAddress) {
- server.ProcessPacket(frame.data(), hdlc_channel_output);
+ server.ProcessPacket(frame.data());
}
}
}
diff --git a/pw_hdlc/public/pw_hdlc/rpc_packets.h b/pw_hdlc/public/pw_hdlc/rpc_packets.h
index 2913021..d52ef2c 100644
--- a/pw_hdlc/public/pw_hdlc/rpc_packets.h
+++ b/pw_hdlc/public/pw_hdlc/rpc_packets.h
@@ -30,14 +30,4 @@
span<std::byte> decode_buffer,
unsigned rpc_address = kDefaultRpcAddress);
-// Reads HDLC frames with sys_io::ReadByte, using decode_buffer to store frames.
-// HDLC frames sent to rpc_address are passed to the RPC server.
-//
-// Note: this overload (with the `ChannelOutput` argument) is deprecated and
-// will be removed.
-Status ReadAndProcessPackets(rpc::Server& server,
- rpc::ChannelOutput& output,
- span<std::byte> decode_buffer,
- unsigned rpc_address = kDefaultRpcAddress);
-
} // namespace pw::hdlc
diff --git a/pw_hdlc/rpc_packets.cc b/pw_hdlc/rpc_packets.cc
index fd42968..6241dc4 100644
--- a/pw_hdlc/rpc_packets.cc
+++ b/pw_hdlc/rpc_packets.cc
@@ -38,11 +38,4 @@
}
}
-Status ReadAndProcessPackets(rpc::Server& server,
- rpc::ChannelOutput&,
- span<std::byte> decode_buffer,
- unsigned rpc_address) {
- return ReadAndProcessPackets(server, decode_buffer, rpc_address);
-}
-
} // namespace pw::hdlc
diff --git a/pw_rpc/client_server.cc b/pw_rpc/client_server.cc
index 1268b17..e6d37b2 100644
--- a/pw_rpc/client_server.cc
+++ b/pw_rpc/client_server.cc
@@ -16,9 +16,8 @@
namespace pw::rpc {
-Status ClientServer::ProcessPacket(ConstByteSpan packet,
- ChannelOutput* interface) {
- Status status = server_.ProcessPacket(packet, interface);
+Status ClientServer::ProcessPacket(ConstByteSpan packet) {
+ Status status = server_.ProcessPacket(packet);
if (status.IsInvalidArgument()) {
// INVALID_ARGUMENT indicates the packet is intended for a client.
status = client_.ProcessPacket(packet);
diff --git a/pw_rpc/client_server_test.cc b/pw_rpc/client_server_test.cc
index bddcea8..15a50e9 100644
--- a/pw_rpc/client_server_test.cc
+++ b/pw_rpc/client_server_test.cc
@@ -56,7 +56,7 @@
Result result = packet.Encode(buffer);
EXPECT_EQ(result.status(), OkStatus());
- EXPECT_EQ(client_server.ProcessPacket(result.value(), output), OkStatus());
+ EXPECT_EQ(client_server.ProcessPacket(result.value()), OkStatus());
}
TEST(ClientServer, ProcessPacket_CallsClient) {
@@ -73,12 +73,12 @@
// No calls are registered on the client, so nothing should happen. The
// ProcessPacket call still returns OK since the client handled it.
- EXPECT_EQ(client_server.ProcessPacket(result.value(), output), OkStatus());
+ EXPECT_EQ(client_server.ProcessPacket(result.value()), OkStatus());
}
TEST(ClientServer, ProcessPacket_BadData) {
ClientServer client_server(channels);
- EXPECT_EQ(client_server.ProcessPacket({}, output), Status::DataLoss());
+ EXPECT_EQ(client_server.ProcessPacket({}), Status::DataLoss());
}
} // namespace
diff --git a/pw_rpc/docs.rst b/pw_rpc/docs.rst
index 732e829..59e2605 100644
--- a/pw_rpc/docs.rst
+++ b/pw_rpc/docs.rst
@@ -316,8 +316,7 @@
std::array<std::byte, kMaxTransmissionUnit> input_buffer;
PW_LOG_INFO("Starting pw_rpc server");
- pw::hdlc::ReadAndProcessPackets(
- server, hdlc_channel_output, input_buffer);
+ pw::hdlc::ReadAndProcessPackets(server, input_buffer);
}
Channels
diff --git a/pw_rpc/nanopb/method_test.cc b/pw_rpc/nanopb/method_test.cc
index 876c7a8..b766a8e 100644
--- a/pw_rpc/nanopb/method_test.cc
+++ b/pw_rpc/nanopb/method_test.cc
@@ -355,8 +355,7 @@
std::array<byte, 128> encoded_request = {};
auto encoded = context.client_stream(request).Encode(encoded_request);
ASSERT_EQ(OkStatus(), encoded.status());
- ASSERT_EQ(OkStatus(),
- context.server().ProcessPacket(*encoded, context.output()));
+ ASSERT_EQ(OkStatus(), context.server().ProcessPacket(*encoded));
EXPECT_EQ(request_struct.integer, 1 << 30);
EXPECT_EQ(request_struct.status_code, 9u);
@@ -397,8 +396,7 @@
std::array<byte, 128> encoded_request = {};
auto encoded = context.client_stream(request).Encode(encoded_request);
ASSERT_EQ(OkStatus(), encoded.status());
- ASSERT_EQ(OkStatus(),
- context.server().ProcessPacket(*encoded, context.output()));
+ ASSERT_EQ(OkStatus(), context.server().ProcessPacket(*encoded));
EXPECT_EQ(request_struct.integer, 1 << 29);
EXPECT_EQ(request_struct.status_code, 8u);
diff --git a/pw_rpc/public/pw_rpc/client_server.h b/pw_rpc/public/pw_rpc/client_server.h
index 78ac841..85da7ca 100644
--- a/pw_rpc/public/pw_rpc/client_server.h
+++ b/pw_rpc/public/pw_rpc/client_server.h
@@ -26,23 +26,12 @@
: client_(channels), server_(channels) {}
// Sends a packet to either the client or the server, depending on its type.
- //
- // ProcessPacket optionally accepts a ChannelOutput as a second argument. If
- // provided, the server will be able to dynamically assign channels as
- // requests come in instead of requiring channels to be known at compile time.
- Status ProcessPacket(ConstByteSpan packet) {
- return ProcessPacket(packet, nullptr);
- }
- Status ProcessPacket(ConstByteSpan packet, ChannelOutput& interface) {
- return ProcessPacket(packet, &interface);
- }
+ Status ProcessPacket(ConstByteSpan packet);
constexpr Client& client() { return client_; }
constexpr Server& server() { return server_; }
private:
- Status ProcessPacket(ConstByteSpan packet, ChannelOutput* interface);
-
Client client_;
Server server_;
};
diff --git a/pw_rpc/public/pw_rpc/internal/test_method_context.h b/pw_rpc/public/pw_rpc/internal/test_method_context.h
index bd01aae..f96efdf 100644
--- a/pw_rpc/public/pw_rpc/internal/test_method_context.h
+++ b/pw_rpc/public/pw_rpc/internal/test_method_context.h
@@ -85,8 +85,7 @@
{},
error)
.Encode(packet)
- .value(),
- output_)
+ .value())
.ok());
}
@@ -122,8 +121,7 @@
0,
payload)
.Encode(packet)
- .value(),
- output_)
+ .value())
.ok());
}
@@ -135,8 +133,7 @@
UnwrapServiceId(service_.service_id()),
kMethodId)
.Encode(packet)
- .value(),
- output_)
+ .value())
.ok());
}
diff --git a/pw_rpc/public/pw_rpc/server.h b/pw_rpc/public/pw_rpc/server.h
index bcb8916..9411564 100644
--- a/pw_rpc/public/pw_rpc/server.h
+++ b/pw_rpc/public/pw_rpc/server.h
@@ -67,22 +67,11 @@
// DATA_LOSS - Failed to decode the packet.
// INVALID_ARGUMENT - The packet is intended for a client, not a server.
// UNAVAILABLE - No RPC channel with the requested ID was found.
- //
- // ProcessPacket optionally accepts a ChannelOutput as a second argument. If
- // provided, the server respond on that interface if an unknown channel is
- // requested.
Status ProcessPacket(ConstByteSpan packet_data)
- PW_LOCKS_EXCLUDED(internal::rpc_lock()) {
- return ProcessPacket(packet_data, nullptr);
- }
- Status ProcessPacket(ConstByteSpan packet_data, ChannelOutput& interface)
- PW_LOCKS_EXCLUDED(internal::rpc_lock()) {
- return ProcessPacket(packet_data, &interface);
- }
+ PW_LOCKS_EXCLUDED(internal::rpc_lock());
private:
friend class internal::Call;
- friend class ClientServer;
// Give call classes access to OpenContext.
friend class RawServerReaderWriter;
@@ -145,9 +134,6 @@
*this, channel_id, service, method, kOpenCallId);
}
- Status ProcessPacket(ConstByteSpan packet_data, ChannelOutput* interface)
- PW_LOCKS_EXCLUDED(internal::rpc_lock());
-
std::tuple<Service*, const internal::Method*> FindMethod(
const internal::Packet& packet)
PW_EXCLUSIVE_LOCKS_REQUIRED(internal::rpc_lock());
diff --git a/pw_rpc/pwpb/method_test.cc b/pw_rpc/pwpb/method_test.cc
index 493e80d..3a31d09 100644
--- a/pw_rpc/pwpb/method_test.cc
+++ b/pw_rpc/pwpb/method_test.cc
@@ -363,8 +363,7 @@
std::array<byte, 128> encoded_request = {};
auto encoded = context.client_stream(request).Encode(encoded_request);
ASSERT_EQ(OkStatus(), encoded.status());
- ASSERT_EQ(OkStatus(),
- context.server().ProcessPacket(*encoded, context.output()));
+ ASSERT_EQ(OkStatus(), context.server().ProcessPacket(*encoded));
EXPECT_EQ(request_struct.integer, 1 << 30);
EXPECT_EQ(request_struct.status_code, 9u);
@@ -407,8 +406,7 @@
std::array<byte, 128> encoded_request = {};
auto encoded = context.client_stream(request).Encode(encoded_request);
ASSERT_EQ(OkStatus(), encoded.status());
- ASSERT_EQ(OkStatus(),
- context.server().ProcessPacket(*encoded, context.output()));
+ ASSERT_EQ(OkStatus(), context.server().ProcessPacket(*encoded));
EXPECT_EQ(request_struct.integer, 1 << 29);
EXPECT_EQ(request_struct.status_code, 8u);
diff --git a/pw_rpc/raw/method_test.cc b/pw_rpc/raw/method_test.cc
index ed2cd3a..0130ba0 100644
--- a/pw_rpc/raw/method_test.cc
+++ b/pw_rpc/raw/method_test.cc
@@ -242,8 +242,7 @@
auto encoded = context.client_stream(as_bytes(span(kRequestValue)))
.Encode(encoded_request);
ASSERT_EQ(OkStatus(), encoded.status());
- ASSERT_EQ(OkStatus(),
- context.server().ProcessPacket(*encoded, context.output()));
+ ASSERT_EQ(OkStatus(), context.server().ProcessPacket(*encoded));
EXPECT_STREQ(reinterpret_cast<const char*>(request.data()), kRequestValue);
}
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index cf7e73f..9ef2c29 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -33,8 +33,7 @@
} // namespace
-Status Server::ProcessPacket(ConstByteSpan packet_data,
- ChannelOutput* interface) {
+Status Server::ProcessPacket(ConstByteSpan packet_data) {
PW_TRY_ASSIGN(Packet packet,
Endpoint::ProcessPacket(packet_data, Packet::kServer));
@@ -51,15 +50,6 @@
internal::Channel* channel = GetInternalChannel(packet.channel_id());
if (channel == nullptr) {
- // If an interface was provided, respond with a SERVER_ERROR to indicate
- // that the channel is not available on this server. Don't send responses to
- // error messages, though, to avoid potential infinite cycles.
- if (interface != nullptr && packet.type() != PacketType::CLIENT_ERROR) {
- internal::Channel(packet.channel_id(), interface)
- .Send(Packet::ServerError(packet, Status::Unavailable()))
- .IgnoreError();
- }
-
internal::rpc_lock().unlock();
PW_LOG_WARN("RPC server received packet for unknown channel %u",
static_cast<unsigned>(packet.channel_id()));
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index 1c2e400..d69fa30 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -127,9 +127,9 @@
};
TEST_F(BasicServer, ProcessPacket_ValidMethodInService1_InvokesMethod) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100)));
const TestMethod& method = service_1_.method(100);
EXPECT_EQ(1u, method.last_channel_id());
@@ -141,9 +141,9 @@
}
TEST_F(BasicServer, ProcessPacket_ValidMethodInService42_InvokesMethod) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 200),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 200)));
const TestMethod& method = service_42_.method(200);
EXPECT_EQ(1u, method.last_channel_id());
@@ -157,9 +157,9 @@
TEST_F(BasicServer, UnregisterService_CannotCallMethod) {
server_.UnregisterService(service_1_, service_42_);
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100)));
const Packet& packet =
static_cast<internal::test::FakeChannelOutput&>(output_).last_packet();
@@ -174,9 +174,9 @@
server_.UnregisterService(service_42_, service_42_, service_42_);
server_.UnregisterService(service_42_);
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 1, 100)));
const TestMethod& method = service_1_.method(100);
EXPECT_EQ(1u, method.last_channel_id());
@@ -188,48 +188,46 @@
}
TEST_F(BasicServer, ProcessPacket_IncompletePacket_NothingIsInvoked) {
+ EXPECT_EQ(
+ Status::DataLoss(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 0, 42, 101)));
+ EXPECT_EQ(
+ Status::DataLoss(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 0, 101)));
EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 0, 42, 101),
- output_));
- EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 0, 101),
- output_));
- EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 0),
- output_));
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 0)));
EXPECT_EQ(0u, service_42_.method(100).last_channel_id());
EXPECT_EQ(0u, service_42_.method(200).last_channel_id());
}
TEST_F(BasicServer, ProcessPacket_NoChannel_SendsNothing) {
- EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 0, 42, 101),
- output_));
+ EXPECT_EQ(
+ Status::DataLoss(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 0, 42, 101)));
EXPECT_EQ(output_.total_packets(), 0u);
}
TEST_F(BasicServer, ProcessPacket_NoService_SendsNothing) {
- EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 0, 101),
- output_));
+ EXPECT_EQ(
+ Status::DataLoss(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 0, 101)));
EXPECT_EQ(output_.total_packets(), 0u);
}
TEST_F(BasicServer, ProcessPacket_NoMethod_SendsNothing) {
EXPECT_EQ(Status::DataLoss(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 0),
- output_));
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 0)));
EXPECT_EQ(output_.total_packets(), 0u);
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 101),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 101)));
EXPECT_EQ(0u, service_42_.method(100).last_channel_id());
EXPECT_EQ(0u, service_42_.method(200).last_channel_id());
@@ -238,15 +236,15 @@
TEST_F(BasicServer, ProcessPacket_ClientErrorWithInvalidMethod_NoResponse) {
EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
- EncodePacket(PacketType::CLIENT_ERROR, 1, 42, 101), output_));
+ EncodePacket(PacketType::CLIENT_ERROR, 1, 42, 101)));
EXPECT_EQ(0u, output_.total_packets());
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 27),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 27)));
const Packet& packet =
static_cast<internal::test::FakeChannelOutput&>(output_).last_packet();
@@ -258,9 +256,9 @@
}
TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 43, 27),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 43, 27)));
const Packet& packet =
static_cast<internal::test::FakeChannelOutput&>(output_).last_packet();
@@ -277,37 +275,19 @@
EncodePacket(PacketType::REQUEST, /*channel_id=*/99, 42, 27)));
}
-TEST_F(BasicServer,
- ProcessPacket_UnassignedChannel_SendsUnavailableToProvidedInterface) {
- EXPECT_EQ(Status::Unavailable(),
- server_.ProcessPacket(
- EncodePacket(PacketType::REQUEST, /*channel_id=*/99, 42, 27),
- output_));
-
- const Packet& packet =
- static_cast<internal::test::FakeChannelOutput&>(output_).last_packet();
- EXPECT_EQ(packet.status(), Status::Unavailable());
- EXPECT_EQ(packet.channel_id(), 99u);
- EXPECT_EQ(packet.service_id(), 42u);
- EXPECT_EQ(packet.method_id(), 27u);
-}
-
TEST_F(BasicServer, ProcessPacket_ClientErrorOnUnassignedChannel_NoResponse) {
channels_[2] = Channel::Create<3>(&output_); // Occupy only available channel
- EXPECT_EQ(
- Status::Unavailable(),
- server_.ProcessPacket(
- EncodePacket(PacketType::CLIENT_ERROR, /*channel_id=*/99, 42, 27),
- output_));
+ EXPECT_EQ(Status::Unavailable(),
+ server_.ProcessPacket(EncodePacket(
+ PacketType::CLIENT_ERROR, /*channel_id=*/99, 42, 27)));
EXPECT_EQ(0u, output_.total_packets());
}
TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsNothing) {
// Set up a fake ServerWriter representing an ongoing RPC.
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodeCancel(1, 42, 100), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(1, 42, 100)));
EXPECT_EQ(output_.total_packets(), 0u);
}
@@ -336,9 +316,9 @@
internal::TestMethod::FakeServerCall call;
service_42_.method(100).keep_call_active(call);
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 100),
- output_));
+ EXPECT_EQ(
+ OkStatus(),
+ server_.ProcessPacket(EncodePacket(PacketType::REQUEST, 1, 42, 100)));
Status on_error_status;
call.set_on_error(
@@ -359,10 +339,10 @@
TEST_F(BasicServer, OpenChannel_UnusedSlot) {
const span request = EncodePacket(PacketType::REQUEST, 9, 42, 100);
- EXPECT_EQ(Status::Unavailable(), server_.ProcessPacket(request, output_));
+ EXPECT_EQ(Status::Unavailable(), server_.ProcessPacket(request));
EXPECT_EQ(OkStatus(), server_.OpenChannel(9, output_));
- EXPECT_EQ(OkStatus(), server_.ProcessPacket(request, output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(request));
const Packet& packet =
static_cast<internal::test::FakeChannelOutput&>(output_).last_packet();
@@ -411,28 +391,27 @@
ASSERT_EQ(method.invocations(), 0u);
EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(PacketForRpc(PacketType::REQUEST), output_));
+ server_.ProcessPacket(PacketForRpc(PacketType::REQUEST)));
EXPECT_EQ(cancelled, 1);
EXPECT_EQ(method.invocations(), 1u);
}
TEST_F(BidiMethod, Cancel_ClosesServerWriter) {
- EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel()));
EXPECT_FALSE(responder_.active());
}
TEST_F(BidiMethod, Cancel_SendsNoResponse) {
- EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel()));
EXPECT_EQ(output_.total_packets(), 0u);
}
TEST_F(BidiMethod, ClientError_ClosesServerWriterWithoutResponse) {
- ASSERT_EQ(
- OkStatus(),
- server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_ERROR), output_));
+ ASSERT_EQ(OkStatus(),
+ server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_ERROR)));
EXPECT_FALSE(responder_.active());
EXPECT_EQ(output_.total_packets(), 0u);
@@ -444,8 +423,7 @@
ASSERT_EQ(OkStatus(),
server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_ERROR,
- Status::Unauthenticated()),
- output_));
+ Status::Unauthenticated())));
EXPECT_EQ(status, Status::Unauthenticated());
}
@@ -454,28 +432,25 @@
Status status = Status::Unknown();
responder_.set_on_error([&status](Status error) { status = error; });
- ASSERT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(), output_));
+ ASSERT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel()));
EXPECT_EQ(status, Status::Cancelled());
}
TEST_F(BidiMethod, Cancel_IncorrectChannel_SendsNothing) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodeCancel(2, 42, 100), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(2, 42, 100)));
EXPECT_EQ(output_.total_packets(), 0u);
EXPECT_TRUE(responder_.active());
}
TEST_F(BidiMethod, Cancel_IncorrectService_SendsNothing) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodeCancel(1, 43, 100), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(1, 43, 100)));
EXPECT_EQ(output_.total_packets(), 0u);
EXPECT_TRUE(responder_.active());
}
TEST_F(BidiMethod, Cancel_IncorrectMethod_SendsNothing) {
- EXPECT_EQ(OkStatus(),
- server_.ProcessPacket(EncodeCancel(1, 42, 101), output_));
+ EXPECT_EQ(OkStatus(), server_.ProcessPacket(EncodeCancel(1, 42, 101)));
EXPECT_EQ(output_.total_packets(), 0u);
EXPECT_TRUE(responder_.active());
}
@@ -486,7 +461,7 @@
ASSERT_EQ(OkStatus(),
server_.ProcessPacket(
- PacketForRpc(PacketType::CLIENT_STREAM, {}, "hello"), output_));
+ PacketForRpc(PacketType::CLIENT_STREAM, {}, "hello")));
EXPECT_EQ(output_.total_packets(), 0u);
EXPECT_STREQ(reinterpret_cast<const char*>(data.data()), "hello");
@@ -512,8 +487,7 @@
responder_.set_on_client_stream_end([&called]() { called = true; });
ASSERT_EQ(OkStatus(),
- server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM_END),
- output_));
+ server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM_END)));
EXPECT_EQ(output_.total_packets(), 0u);
EXPECT_TRUE(called);
@@ -521,12 +495,12 @@
TEST_F(BidiMethod, ClientStreamEnd_ErrorWhenClosed) {
const auto end = PacketForRpc(PacketType::CLIENT_STREAM_END);
- ASSERT_EQ(OkStatus(), server_.ProcessPacket(end, output_));
+ ASSERT_EQ(OkStatus(), server_.ProcessPacket(end));
bool called = false;
responder_.set_on_client_stream_end([&called]() { called = true; });
- ASSERT_EQ(OkStatus(), server_.ProcessPacket(end, output_));
+ ASSERT_EQ(OkStatus(), server_.ProcessPacket(end));
ASSERT_EQ(output_.total_packets(), 1u);
const Packet& packet =
@@ -554,9 +528,8 @@
};
TEST_F(ServerStreamingMethod, ClientStream_InvalidArgumentError) {
- ASSERT_EQ(
- OkStatus(),
- server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM), output_));
+ ASSERT_EQ(OkStatus(),
+ server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM)));
ASSERT_EQ(output_.total_packets(), 1u);
const Packet& packet =
@@ -567,8 +540,7 @@
TEST_F(ServerStreamingMethod, ClientStreamEnd_InvalidArgumentError) {
ASSERT_EQ(OkStatus(),
- server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM_END),
- output_));
+ server_.ProcessPacket(PacketForRpc(PacketType::CLIENT_STREAM_END)));
ASSERT_EQ(output_.total_packets(), 1u);
const Packet& packet =
diff --git a/pw_rpc/size_report/server_only.cc b/pw_rpc/size_report/server_only.cc
index 97c91f9..a8644f7 100644
--- a/pw_rpc/size_report/server_only.cc
+++ b/pw_rpc/size_report/server_only.cc
@@ -50,7 +50,7 @@
pw::sys_io::WriteBytes(packet_buffer)
.IgnoreError(); // TODO(b/242598609): Handle Status properly
- my_product::server.ProcessPacket(packet_buffer, my_product::output)
+ my_product::server.ProcessPacket(packet_buffer)
.IgnoreError(); // TODO(b/242598609): Handle Status properly
return static_cast<int>(packet_buffer[92]);
diff --git a/pw_system/hdlc_rpc_server.cc b/pw_system/hdlc_rpc_server.cc
index dc8ab2f..5bbcd83 100644
--- a/pw_system/hdlc_rpc_server.cc
+++ b/pw_system/hdlc_rpc_server.cc
@@ -70,7 +70,7 @@
if (auto result = decoder.Process(byte); result.ok()) {
hdlc::Frame& frame = result.value();
if (frame.address() == PW_SYSTEM_DEFAULT_RPC_HDLC_ADDRESS) {
- server.ProcessPacket(frame.data(), hdlc_channel_output);
+ server.ProcessPacket(frame.data());
}
}
}
diff --git a/targets/host/system_rpc_server.cc b/targets/host/system_rpc_server.cc
index a0f53d8..6de5567 100644
--- a/targets/host/system_rpc_server.cc
+++ b/targets/host/system_rpc_server.cc
@@ -95,7 +95,7 @@
continue;
}
- server.ProcessPacket(frame.data(), hdlc_channel_output).IgnoreError();
+ server.ProcessPacket(frame.data()).IgnoreError();
}
}
}
