blob: 798fdfe97a020c289986a74d635a0b93e25162ac [file] [log] [blame]
// Copyright 2022 The Chromium 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 <string>
#include <string_view>
#include <utility>
#include "ipcz/ipcz.h"
#include "reference_drivers/blob.h"
#include "test/multinode_test.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/strings/str_cat.h"
namespace ipcz {
namespace {
using RemotePortalTestNode = test::TestNode;
using RemotePortalTest = test::MultinodeTest<RemotePortalTestNode>;
static constexpr std::string_view kTestMessage1 = "hello world";
static constexpr std::string_view kTestMessage2 = "hola mundo";
MULTINODE_TEST_NODE(RemotePortalTestNode, BasicConnectionClient) {
IpczHandle b = ConnectToBroker();
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, kTestMessage1));
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, &message));
EXPECT_EQ(kTestMessage2, message);
Close(b);
}
TEST_P(RemotePortalTest, BasicConnection) {
IpczHandle c = SpawnTestNode<BasicConnectionClient>();
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c, &message));
EXPECT_EQ(kTestMessage1, message);
EXPECT_EQ(IPCZ_RESULT_OK, Put(c, kTestMessage2));
Close(c);
}
MULTINODE_TEST_NODE(RemotePortalTestNode, PortalTransferClient) {
IpczHandle b = ConnectToBroker();
IpczHandle p = IPCZ_INVALID_HANDLE;
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, &message, {&p, 1}));
EXPECT_EQ(kTestMessage1, message);
EXPECT_NE(IPCZ_INVALID_HANDLE, p);
VerifyEndToEnd(p);
WaitForDirectRemoteLink(p);
CloseAll({p, b});
}
TEST_P(RemotePortalTest, PortalTransfer) {
IpczHandle c = SpawnTestNode<PortalTransferClient>();
auto [q, p] = OpenPortals();
EXPECT_EQ(IPCZ_RESULT_OK, Put(c, kTestMessage1, {&p, 1}));
VerifyEndToEnd(q);
WaitForDirectRemoteLink(q);
CloseAll({q, c});
}
constexpr size_t kMultipleHopsNumIterations = 100;
MULTINODE_TEST_NODE(RemotePortalTestNode, MultipleHopsClient1) {
IpczHandle b = ConnectToBroker();
auto [q, p] = OpenPortals();
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, "", {&p, 1}));
for (size_t i = 0; i < kMultipleHopsNumIterations; ++i) {
EXPECT_EQ(IPCZ_RESULT_OK, Put(q, kTestMessage2));
}
for (size_t i = 0; i < kMultipleHopsNumIterations; ++i) {
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(q, &message));
EXPECT_EQ(kTestMessage1, message);
}
WaitForDirectRemoteLink(q);
PingPong(b);
CloseAll({q, b});
}
MULTINODE_TEST_NODE(RemotePortalTestNode, MultipleHopsClient2) {
IpczHandle b = ConnectToBroker();
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&p, 1}));
for (size_t i = 0; i < kMultipleHopsNumIterations; ++i) {
EXPECT_EQ(IPCZ_RESULT_OK, Put(p, kTestMessage1));
}
for (size_t i = 0; i < kMultipleHopsNumIterations; ++i) {
std::string message;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(p, &message));
EXPECT_EQ(kTestMessage2, message);
}
WaitForDirectRemoteLink(p);
PingPong(b);
CloseAll({p, b});
}
TEST_P(RemotePortalTest, MultipleHops) {
IpczHandle c1 = SpawnTestNode<MultipleHopsClient1>();
IpczHandle c2 = SpawnTestNode<MultipleHopsClient2>();
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c1, nullptr, {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c2, "", {&p, 1}));
WaitForPingAndReply(c1);
WaitForPingAndReply(c2);
CloseAll({c1, c2});
}
constexpr size_t kTransferBackAndForthNumIterations = 100;
MULTINODE_TEST_NODE(RemotePortalTestNode, TransferBackAndForthClient) {
IpczHandle b = ConnectToBroker();
for (size_t i = 0; i < kTransferBackAndForthNumIterations; ++i) {
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, "", {&p, 1}));
}
EXPECT_EQ(IPCZ_RESULT_OK, WaitForConditionFlags(b, IPCZ_TRAP_PEER_CLOSED));
Close(b);
}
TEST_P(RemotePortalTest, TransferBackAndForth) {
IpczHandle c = SpawnTestNode<TransferBackAndForthClient>();
constexpr std::string_view kMessage = "hihihihi";
auto [q, p] = OpenPortals();
std::string message;
for (size_t i = 0; i < kTransferBackAndForthNumIterations; ++i) {
EXPECT_EQ(IPCZ_RESULT_OK, Put(q, kMessage));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c, "", {&p, 1}));
p = IPCZ_INVALID_HANDLE;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c, nullptr, {&p, 1}));
EXPECT_NE(IPCZ_INVALID_HANDLE, p);
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(p, &message));
EXPECT_EQ(kMessage, message);
}
VerifyEndToEndLocal(q, p);
WaitForDirectLocalLink(q, p);
CloseAll({q, p, c});
}
constexpr size_t kHugeNumberOfPortalsCount = 1000;
MULTINODE_TEST_NODE(RemotePortalTestNode, HugeNumberOfPortalsClient) {
IpczHandle b = ConnectToBroker();
IpczHandle other_client;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&other_client, 1}));
std::vector<IpczHandle> portals(kHugeNumberOfPortalsCount);
for (auto& portal : portals) {
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&portal, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(other_client, "", {&portal, 1}));
}
for (size_t i = 0; i < kHugeNumberOfPortalsCount; ++i) {
EXPECT_EQ(IPCZ_RESULT_OK,
WaitToGet(other_client, nullptr, {&portals[i], 1}));
IpczDriverHandle blob = reference_drivers::Blob::ReleaseAsHandle(
MakeRefCounted<reference_drivers::Blob>(absl::StrCat(absl::Dec(i))));
IpczHandle box;
EXPECT_EQ(IPCZ_RESULT_OK,
ipcz().Box(node(), blob, IPCZ_NO_FLAGS, nullptr, &box));
EXPECT_EQ(IPCZ_RESULT_OK, Put(portals[i], "", {&box, 1}));
}
for (size_t i = 0; i < kHugeNumberOfPortalsCount; ++i) {
IpczHandle box;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(portals[i], nullptr, {&box, 1}));
IpczDriverHandle blob;
EXPECT_EQ(IPCZ_RESULT_OK, ipcz().Unbox(box, IPCZ_NO_FLAGS, nullptr, &blob));
EXPECT_EQ(absl::StrCat(absl::Dec(i)),
reference_drivers::Blob::TakeFromHandle(blob)->message());
}
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, "", {&other_client, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitForConditionFlags(b, IPCZ_TRAP_PEER_CLOSED));
CloseAll(portals);
Close(b);
}
TEST_P(RemotePortalTest, HugeNumberOfPortals) {
// Opens a very large number of portals, and sends them all to client nodes.
// The client nodes exchange these portals with each other and transmit
// parcels over them, with and without driver objects. This exercises
// NodeLinkMemory allocations and related synchronization around e.g.
// delegated allocation and driver object relaying.
IpczHandle c1 = SpawnTestNode<HugeNumberOfPortalsClient>();
IpczHandle c2 = SpawnTestNode<HugeNumberOfPortalsClient>();
auto [q, p] = OpenPortals();
EXPECT_EQ(IPCZ_RESULT_OK, Put(c1, "", {&q, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c2, "", {&p, 1}));
for (size_t i = 0; i < kHugeNumberOfPortalsCount; ++i) {
auto [a, b] = OpenPortals();
EXPECT_EQ(IPCZ_RESULT_OK, Put(c1, "", {&a, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c2, "", {&b, 1}));
}
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c1, nullptr, {&q, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c2, nullptr, {&p, 1}));
WaitForDirectLocalLink(q, p);
CloseAll({c1, c2, q, p});
}
constexpr size_t kRouteExpansionStressTestNumIterations = 100;
MULTINODE_TEST_NODE(RemotePortalTestNode, RoutingStressTestClient) {
// Each client only expects portals from the broker and bounces them back.
IpczHandle b = ConnectToBroker();
for (size_t i = 0; i < kRouteExpansionStressTestNumIterations; ++i) {
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, "", {&p, 1}));
}
EXPECT_EQ(IPCZ_RESULT_OK, WaitForConditionFlags(b, IPCZ_TRAP_PEER_CLOSED));
Close(b);
}
TEST_P(RemotePortalTest, RoutingStressTest) {
// This test spawns a bunch of nodes and bounces two portals back and forth
// among them over a large number of iterations, then waits for all the
// intermediate routers to be removed. Every iteration also sends a message
// from each end of the pipe to exercise parcel routing, including with
// driver objects attached.
constexpr size_t kNumClientPairs = 3;
std::pair<IpczHandle, IpczHandle> client_pairs[kNumClientPairs];
for (auto& pair : client_pairs) {
pair = std::make_pair(SpawnTestNode<RoutingStressTestClient>(),
SpawnTestNode<RoutingStressTestClient>());
}
auto [a, b] = OpenPortals();
for (size_t j = 0; j < kRouteExpansionStressTestNumIterations; ++j) {
IpczDriverHandle blob = reference_drivers::Blob::ReleaseAsHandle(
MakeRefCounted<reference_drivers::Blob>(absl::StrCat(absl::Dec(j))));
IpczHandle box;
EXPECT_EQ(IPCZ_RESULT_OK,
ipcz().Box(node(), blob, IPCZ_NO_FLAGS, nullptr, &box));
EXPECT_EQ(IPCZ_RESULT_OK,
Put(a, absl::StrCat("a", absl::Dec(j)), {&box, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, absl::StrCat("b", absl::Dec(j))));
for (auto& pair : client_pairs) {
EXPECT_EQ(IPCZ_RESULT_OK, Put(pair.first, "", {&a, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(pair.second, "", {&b, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(pair.first, nullptr, {&a, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(pair.second, nullptr, {&b, 1}));
}
}
WaitForDirectLocalLink(a, b);
for (size_t i = 0; i < kRouteExpansionStressTestNumIterations; ++i) {
std::string message;
IpczHandle box;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(a, &message));
EXPECT_EQ(absl::StrCat("b", absl::Dec(i)), message);
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, &message, {&box, 1}));
EXPECT_EQ(absl::StrCat("a", absl::Dec(i)), message);
IpczDriverHandle blob;
EXPECT_EQ(IPCZ_RESULT_OK, ipcz().Unbox(box, IPCZ_NO_FLAGS, nullptr, &blob));
EXPECT_EQ(absl::StrCat(absl::Dec(i)),
reference_drivers::Blob::TakeFromHandle(blob)->message());
}
for (auto& pair : client_pairs) {
CloseAll({pair.first, pair.second});
}
CloseAll({a, b});
}
MULTINODE_TEST_NODE(RemotePortalTestNode, DisconnectThroughProxyClient1) {
IpczHandle b = ConnectToBroker();
IpczHandle q;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&q, 1}));
// Should eventually be observed by virtue of the forced disconnection of
// client 3 in the main test body.
EXPECT_EQ(IPCZ_RESULT_OK, WaitForConditionFlags(q, IPCZ_TRAP_PEER_CLOSED));
CloseAll({q, b});
}
MULTINODE_TEST_NODE(RemotePortalTestNode, DisconnectThroughProxyClient2) {
IpczHandle b = ConnectToBroker();
// Receive a portal p from the broker and bounce it back.
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(b, "", {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, WaitForConditionFlags(b, IPCZ_TRAP_PEER_CLOSED));
Close(b);
}
MULTINODE_TEST_NODE(RemotePortalTestNode, DisconnectThroughProxyClient3) {
IpczHandle b = ConnectToBroker();
// Receive a portal p from the broker and then immediately terminate this
// node.
IpczHandle p;
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(b, nullptr, {&p, 1}));
// Forcibly shut this node down, severing all connections to other nodes. We
// do this *before* closing `p` to ensure that we are't just exercising normal
// portal closure, which other tests already cover. From the perspective of
// other nodes, we are effectively simulating a crash of this node.
CloseThisNode();
// It's still necessary to explicitly close local portals after the node
// itself has been shut down. Otherwise they'd leak.
CloseAll({p, b});
}
#if BUILDFLAG(IS_LINUX) && defined(ADDRESS_SANITIZER)
#define MAYBE_DisconnectThroughProxy DISABLED_DisconnectThroughProxy
#else
#define MAYBE_DisconnectThroughProxy DisconnectThroughProxy
#endif
TEST_P(RemotePortalTest, MAYBE_DisconnectThroughProxy) {
// Exercises node disconnection. Namely if portals on nodes 1 and 3 are
// connected via proxy on node 2, and node 3 disappears, node 1's portal
// should observe peer closure.
IpczHandle c1, c3;
auto c1_control = SpawnTestNode<DisconnectThroughProxyClient1>({&c1, 1});
IpczHandle c2 = SpawnTestNode<DisconnectThroughProxyClient2>();
auto c3_control = SpawnTestNode<DisconnectThroughProxyClient3>({&c3, 1});
auto [q, p] = OpenPortals();
// We send q to client 1, and p to client 2.
EXPECT_EQ(IPCZ_RESULT_OK, Put(c1, "", {&q, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c2, "", {&p, 1}));
// Client 2 forwards p back to us, and we forward it now to client 3. This
// process ensures that client 2 will for some time serve as a proxy between
// client 1 and client 3.
EXPECT_EQ(IPCZ_RESULT_OK, WaitToGet(c2, nullptr, {&p, 1}));
EXPECT_EQ(IPCZ_RESULT_OK, Put(c3, "", {&p, 1}));
// Client 3 will terminate on its own. Though not determinstic, this will
// race with proxy reduction such that client 2 may still be proxying for the
// q-p portal pair when client 3 (who owns p) goes away.
EXPECT_TRUE(c3_control->WaitForShutdown());
// Client 1 waits on q observing peer closure before terminating. This will
// block until that happens.
EXPECT_TRUE(c1_control->WaitForShutdown());
CloseAll({c1, c2, c3});
}
INSTANTIATE_MULTINODE_TEST_SUITE_P(RemotePortalTest);
} // namespace
} // namespace ipcz