Switch routing from dest endpoint id to dest ip in network emulation layer
Bug: webrtc:10138
Change-Id: I8659777820ec7244c1435d71504b0c01fb438192
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/130103
Reviewed-by: Yves Gerey <yvesg@google.com>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27386}diff --git a/test/scenario/call_client.cc b/test/scenario/call_client.cc
index 47da762..a98c3e0 100644
--- a/test/scenario/call_client.cc
+++ b/test/scenario/call_client.cc
@@ -195,10 +195,10 @@
void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
// Removes added overhead before delivering packet to sender.
- RTC_DCHECK_GE(packet.data.size(),
- route_overhead_.at(packet.dest_endpoint_id).bytes());
- packet.data.SetSize(packet.data.size() -
- route_overhead_.at(packet.dest_endpoint_id).bytes());
+ size_t size =
+ packet.data.size() - route_overhead_.at(packet.to.ipaddr()).bytes();
+ RTC_DCHECK_GE(size, 0);
+ packet.data.SetSize(size);
MediaType media_type = MediaType::ANY;
if (!RtpHeaderParser::IsRtcp(packet.cdata(), packet.data.size())) {
diff --git a/test/scenario/call_client.h b/test/scenario/call_client.h
index 14c283d..c7ef65e 100644
--- a/test/scenario/call_client.h
+++ b/test/scenario/call_client.h
@@ -112,7 +112,7 @@
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_;
// Stores the configured overhead per known destination endpoint. This is used
// to subtract the overhead before processing.
- std::map<uint64_t, DataSize> route_overhead_;
+ std::map<rtc::IPAddress, DataSize> route_overhead_;
int next_video_ssrc_index_ = 0;
int next_video_local_ssrc_index_ = 0;
int next_rtx_ssrc_index_ = 0;
diff --git a/test/scenario/network/network_emulation.cc b/test/scenario/network/network_emulation.cc
index 2021248..03e2bf4 100644
--- a/test/scenario/network/network_emulation.cc
+++ b/test/scenario/network/network_emulation.cc
@@ -21,12 +21,10 @@
EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
- uint64_t dest_endpoint_id,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time)
: from(from),
to(to),
- dest_endpoint_id(dest_endpoint_id),
data(data),
arrival_time(arrival_time) {}
EmulatedIpPacket::~EmulatedIpPacket() = default;
@@ -34,19 +32,19 @@
EmulatedIpPacket& EmulatedIpPacket::operator=(EmulatedIpPacket&&) = default;
void EmulatedNetworkNode::CreateRoute(
- uint64_t receiver_id,
+ rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes,
EmulatedNetworkReceiverInterface* receiver) {
RTC_CHECK(!nodes.empty());
for (size_t i = 0; i + 1 < nodes.size(); ++i)
- nodes[i]->SetReceiver(receiver_id, nodes[i + 1]);
- nodes.back()->SetReceiver(receiver_id, receiver);
+ nodes[i]->SetReceiver(receiver_ip, nodes[i + 1]);
+ nodes.back()->SetReceiver(receiver_ip, receiver);
}
-void EmulatedNetworkNode::ClearRoute(uint64_t receiver_id,
+void EmulatedNetworkNode::ClearRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes) {
for (EmulatedNetworkNode* node : nodes)
- node->RemoveReceiver(receiver_id);
+ node->RemoveReceiver(receiver_ip);
}
EmulatedNetworkNode::EmulatedNetworkNode(
@@ -57,7 +55,7 @@
void EmulatedNetworkNode::OnPacketReceived(EmulatedIpPacket packet) {
rtc::CritScope crit(&lock_);
- if (routing_.find(packet.dest_endpoint_id) == routing_.end()) {
+ if (routing_.find(packet.to.ipaddr()) == routing_.end()) {
return;
}
uint64_t packet_id = next_packet_id_++;
@@ -92,7 +90,7 @@
}
RTC_CHECK(packet);
RTC_DCHECK(!packet->removed);
- receiver = routing_[packet->packet.dest_endpoint_id];
+ receiver = routing_[packet->packet.to.ipaddr()];
packet->removed = true;
}
RTC_CHECK(receiver);
@@ -113,19 +111,18 @@
}
void EmulatedNetworkNode::SetReceiver(
- uint64_t dest_endpoint_id,
+ rtc::IPAddress dest_ip,
EmulatedNetworkReceiverInterface* receiver) {
rtc::CritScope crit(&lock_);
- RTC_CHECK(routing_
- .insert(std::pair<uint64_t, EmulatedNetworkReceiverInterface*>(
- dest_endpoint_id, receiver))
- .second)
- << "Routing for endpoint " << dest_endpoint_id << " already exists";
+ EmulatedNetworkReceiverInterface* cur_receiver = routing_[dest_ip];
+ RTC_CHECK(cur_receiver == nullptr || cur_receiver == receiver)
+ << "Routing for dest_ip=" << dest_ip.ToString() << " already exists";
+ routing_[dest_ip] = receiver;
}
-void EmulatedNetworkNode::RemoveReceiver(uint64_t dest_endpoint_id) {
+void EmulatedNetworkNode::RemoveReceiver(rtc::IPAddress dest_ip) {
rtc::CritScope crit(&lock_);
- routing_.erase(dest_endpoint_id);
+ routing_.erase(dest_ip);
}
EmulatedEndpoint::EmulatedEndpoint(uint64_t id,
@@ -137,8 +134,7 @@
is_enabled_(is_enabled),
send_node_(nullptr),
clock_(clock),
- next_port_(kFirstEphemeralPort),
- connected_endpoint_id_(absl::nullopt) {
+ next_port_(kFirstEphemeralPort) {
constexpr int kIPv4NetworkPrefixLength = 24;
constexpr int kIPv6NetworkPrefixLength = 64;
@@ -170,11 +166,10 @@
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet) {
RTC_CHECK(from.ipaddr() == peer_local_addr_);
- RTC_CHECK(connected_endpoint_id_);
RTC_CHECK(send_node_);
- send_node_->OnPacketReceived(EmulatedIpPacket(
- from, to, connected_endpoint_id_.value(), std::move(packet),
- Timestamp::us(clock_->TimeInMicroseconds())));
+ send_node_->OnPacketReceived(
+ EmulatedIpPacket(from, to, std::move(packet),
+ Timestamp::us(clock_->TimeInMicroseconds())));
}
absl::optional<uint16_t> EmulatedEndpoint::BindReceiver(
@@ -228,9 +223,10 @@
}
void EmulatedEndpoint::OnPacketReceived(EmulatedIpPacket packet) {
- RTC_CHECK(packet.dest_endpoint_id == id_)
- << "Routing error: wrong destination endpoint. Destination id: "
- << packet.dest_endpoint_id << "; Receiver id: " << id_;
+ RTC_CHECK(packet.to.ipaddr() == peer_local_addr_)
+ << "Routing error: wrong destination endpoint. Packet.to.ipaddr()=: "
+ << packet.to.ipaddr().ToString()
+ << "; Receiver peer_local_addr_=" << peer_local_addr_.ToString();
rtc::CritScope crit(&receiver_lock_);
auto it = port_to_receiver_.find(packet.to.port());
if (it == port_to_receiver_.end()) {
@@ -268,10 +264,6 @@
return send_node_;
}
-void EmulatedEndpoint::SetConnectedEndpointId(uint64_t endpoint_id) {
- connected_endpoint_id_ = endpoint_id;
-}
-
EndpointsContainer::EndpointsContainer(
const std::vector<EmulatedEndpoint*>& endpoints)
: endpoints_(endpoints) {}
@@ -279,8 +271,8 @@
EmulatedEndpoint* EndpointsContainer::LookupByLocalAddress(
const rtc::IPAddress& local_ip) const {
for (auto* endpoint : endpoints_) {
- rtc::IPAddress peerLocalAddress = endpoint->GetPeerLocalAddress();
- if (peerLocalAddress == local_ip) {
+ rtc::IPAddress peer_local_address = endpoint->GetPeerLocalAddress();
+ if (peer_local_address == local_ip) {
return endpoint;
}
}
diff --git a/test/scenario/network/network_emulation.h b/test/scenario/network/network_emulation.h
index 309d511..ec39dfe 100644
--- a/test/scenario/network/network_emulation.h
+++ b/test/scenario/network/network_emulation.h
@@ -43,7 +43,6 @@
public:
EmulatedIpPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
- uint64_t dest_endpoint_id,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time);
~EmulatedIpPacket();
@@ -59,7 +58,6 @@
rtc::SocketAddress from;
rtc::SocketAddress to;
- uint64_t dest_endpoint_id;
rtc::CopyOnWriteBuffer data;
Timestamp arrival_time;
};
@@ -87,16 +85,16 @@
void OnPacketReceived(EmulatedIpPacket packet) override;
void Process(Timestamp at_time);
- void SetReceiver(uint64_t dest_endpoint_id,
+ void SetReceiver(rtc::IPAddress dest_ip,
EmulatedNetworkReceiverInterface* receiver);
- void RemoveReceiver(uint64_t dest_endpoint_id);
+ void RemoveReceiver(rtc::IPAddress dest_ip);
- // Creates a route for the given receiver_id over all the given nodes to the
+ // Creates a route for the given receiver_ip over all the given nodes to the
// given receiver.
- static void CreateRoute(uint64_t receiver_id,
+ static void CreateRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes,
EmulatedNetworkReceiverInterface* receiver);
- static void ClearRoute(uint64_t receiver_id,
+ static void ClearRoute(rtc::IPAddress receiver_ip,
std::vector<EmulatedNetworkNode*> nodes);
private:
@@ -107,7 +105,7 @@
};
rtc::CriticalSection lock_;
- std::map<uint64_t, EmulatedNetworkReceiverInterface*> routing_
+ std::map<rtc::IPAddress, EmulatedNetworkReceiverInterface*> routing_
RTC_GUARDED_BY(lock_);
const std::unique_ptr<NetworkBehaviorInterface> network_behavior_
RTC_GUARDED_BY(lock_);
@@ -170,7 +168,6 @@
friend class test::NetworkEmulationManagerImpl;
EmulatedNetworkNode* GetSendNode() const;
- void SetConnectedEndpointId(uint64_t endpoint_id);
private:
static constexpr uint16_t kFirstEphemeralPort = 49152;
@@ -190,8 +187,6 @@
uint16_t next_port_ RTC_GUARDED_BY(receiver_lock_);
std::map<uint16_t, EmulatedNetworkReceiverInterface*> port_to_receiver_
RTC_GUARDED_BY(receiver_lock_);
-
- absl::optional<uint64_t> connected_endpoint_id_;
};
class EmulatedRoute {
diff --git a/test/scenario/network/network_emulation_manager.cc b/test/scenario/network/network_emulation_manager.cc
index 9c634ea..94b5373 100644
--- a/test/scenario/network/network_emulation_manager.cc
+++ b/test/scenario/network/network_emulation_manager.cc
@@ -112,11 +112,10 @@
from->SetSendNode(via_nodes[0]);
EmulatedNetworkNode* cur_node = via_nodes[0];
for (size_t i = 1; i < via_nodes.size(); ++i) {
- cur_node->SetReceiver(to->GetId(), via_nodes[i]);
+ cur_node->SetReceiver(to->GetPeerLocalAddress(), via_nodes[i]);
cur_node = via_nodes[i];
}
- cur_node->SetReceiver(to->GetId(), to);
- from->SetConnectedEndpointId(to->GetId());
+ cur_node->SetReceiver(to->GetPeerLocalAddress(), to);
std::unique_ptr<EmulatedRoute> route =
absl::make_unique<EmulatedRoute>(from, std::move(via_nodes), to);
@@ -130,11 +129,12 @@
// Remove receiver from intermediate nodes.
for (auto* node : route->via_nodes) {
- node->RemoveReceiver(route->to->GetId());
+ node->RemoveReceiver(route->to->GetPeerLocalAddress());
}
// Detach endpoint from current send node.
if (route->from->GetSendNode()) {
- route->from->GetSendNode()->RemoveReceiver(route->to->GetId());
+ route->from->GetSendNode()->RemoveReceiver(
+ route->to->GetPeerLocalAddress());
route->from->SetSendNode(nullptr);
}
@@ -149,10 +149,10 @@
// Setup a route via specified nodes.
EmulatedNetworkNode* cur_node = via_nodes[0];
for (size_t i = 1; i < via_nodes.size(); ++i) {
- cur_node->SetReceiver(endpoint->GetId(), via_nodes[i]);
+ cur_node->SetReceiver(endpoint->GetPeerLocalAddress(), via_nodes[i]);
cur_node = via_nodes[i];
}
- cur_node->SetReceiver(endpoint->GetId(), endpoint);
+ cur_node->SetReceiver(endpoint->GetPeerLocalAddress(), endpoint);
std::unique_ptr<TrafficRoute> traffic_route =
absl::make_unique<TrafficRoute>(clock_, via_nodes[0], endpoint);
diff --git a/test/scenario/network/traffic_route.cc b/test/scenario/network/traffic_route.cc
index 8af7673..6727a24 100644
--- a/test/scenario/network/traffic_route.cc
+++ b/test/scenario/network/traffic_route.cc
@@ -89,7 +89,7 @@
receiver_->OnPacketReceived(EmulatedIpPacket(
/*from=*/rtc::SocketAddress(),
rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port),
- endpoint_->GetId(), rtc::CopyOnWriteBuffer(packet_size),
+ rtc::CopyOnWriteBuffer(packet_size),
Timestamp::us(clock_->TimeInMicroseconds())));
}
diff --git a/test/scenario/network_node.cc b/test/scenario/network_node.cc
index a206a5f..e0f8f8e 100644
--- a/test/scenario/network_node.cc
+++ b/test/scenario/network_node.cc
@@ -106,9 +106,8 @@
rtc::CopyOnWriteBuffer buffer(packet, length,
length + packet_overhead_.bytes());
buffer.SetSize(length + packet_overhead_.bytes());
- send_net_->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, receiver_id_,
- buffer, send_time));
+ send_net_->OnPacketReceived(
+ EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
return true;
}
@@ -119,34 +118,41 @@
buffer.SetSize(length + packet_overhead_.bytes());
if (!send_net_)
return false;
- send_net_->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, receiver_id_,
- buffer, send_time));
+ send_net_->OnPacketReceived(
+ EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time));
return true;
}
void NetworkNodeTransport::Connect(EmulatedNetworkNode* send_node,
- uint64_t receiver_id,
+ rtc::IPAddress receiver_ip,
DataSize packet_overhead) {
+ // Only IPv4 address is supported. We don't use full range of IPs in scenario
+ // framework and also we need a simple way to convert IP into network_id
+ // to signal network route.
+ RTC_CHECK_EQ(receiver_ip.family(), AF_INET);
+ RTC_CHECK_LE(receiver_ip.v4AddressAsHostOrderInteger(),
+ std::numeric_limits<uint16_t>::max());
rtc::CritScope crit(&crit_sect_);
send_net_ = send_node;
- receiver_id_ = receiver_id;
+ receiver_address_ = rtc::SocketAddress(receiver_ip, 0);
packet_overhead_ = packet_overhead;
rtc::NetworkRoute route;
route.connected = true;
- route.local_network_id = receiver_id;
- route.remote_network_id = receiver_id;
+ route.local_network_id =
+ static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
+ route.remote_network_id =
+ static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
std::string transport_name = "dummy";
sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged(
transport_name, route);
}
CrossTrafficSource::CrossTrafficSource(EmulatedNetworkReceiverInterface* target,
- uint64_t receiver_id,
+ rtc::IPAddress receiver_ip,
CrossTrafficConfig config)
: target_(target),
- receiver_id_(receiver_id),
+ receiver_address_(receiver_ip, 0),
config_(config),
random_(config.random_seed) {}
@@ -179,8 +185,8 @@
pending_size_ += TrafficRate() * delta;
if (pending_size_ > config_.min_packet_size) {
target_->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/,
- receiver_id_, rtc::CopyOnWriteBuffer(pending_size_.bytes()), at_time));
+ rtc::SocketAddress() /*from*/, receiver_address_,
+ rtc::CopyOnWriteBuffer(pending_size_.bytes()), at_time));
pending_size_ = DataSize::Zero();
}
}
diff --git a/test/scenario/network_node.h b/test/scenario/network_node.h
index bdaf2fe..71b7de9 100644
--- a/test/scenario/network_node.h
+++ b/test/scenario/network_node.h
@@ -75,7 +75,7 @@
bool SendRtcp(const uint8_t* packet, size_t length) override;
void Connect(EmulatedNetworkNode* send_node,
- uint64_t receiver_id,
+ rtc::IPAddress receiver_ip,
DataSize packet_overhead);
DataSize packet_overhead() {
@@ -87,8 +87,10 @@
rtc::CriticalSection crit_sect_;
Clock* const sender_clock_;
Call* const sender_call_;
+ // Store local address here for consistency with receiver address.
+ const rtc::SocketAddress local_address_;
EmulatedNetworkNode* send_net_ RTC_GUARDED_BY(crit_sect_) = nullptr;
- uint64_t receiver_id_ RTC_GUARDED_BY(crit_sect_) = 0;
+ rtc::SocketAddress receiver_address_ RTC_GUARDED_BY(crit_sect_);
DataSize packet_overhead_ RTC_GUARDED_BY(crit_sect_) = DataSize::Zero();
};
@@ -103,12 +105,12 @@
private:
friend class Scenario;
CrossTrafficSource(EmulatedNetworkReceiverInterface* target,
- uint64_t receiver_id,
+ rtc::IPAddress receiver_ip,
CrossTrafficConfig config);
void Process(Timestamp at_time, TimeDelta delta);
EmulatedNetworkReceiverInterface* const target_;
- const uint64_t receiver_id_;
+ const rtc::SocketAddress receiver_address_;
CrossTrafficConfig config_;
webrtc::Random random_;
diff --git a/test/scenario/scenario.cc b/test/scenario/scenario.cc
index 09e70f0..3e9fd40 100644
--- a/test/scenario/scenario.cc
+++ b/test/scenario/scenario.cc
@@ -155,10 +155,10 @@
void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
std::vector<EmulatedNetworkNode*> over_nodes,
DataSize overhead) {
- uint64_t route_id = next_route_id_++;
- clients.second->route_overhead_.insert({route_id, overhead});
- EmulatedNetworkNode::CreateRoute(route_id, over_nodes, clients.second);
- clients.first->transport_->Connect(over_nodes.front(), route_id, overhead);
+ rtc::IPAddress route_ip(next_route_id_++);
+ clients.second->route_overhead_.insert({route_ip, overhead});
+ EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, clients.second);
+ clients.first->transport_->Connect(over_nodes.front(), route_ip, overhead);
}
SimulatedTimeClient* Scenario::CreateSimulatedTimeClient(
@@ -167,11 +167,11 @@
std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link) {
- uint64_t send_id = next_route_id_++;
- uint64_t return_id = next_route_id_++;
+ rtc::IPAddress send_ip(next_route_id_++);
+ rtc::IPAddress return_ip(next_route_id_++);
SimulatedTimeClient* client = new SimulatedTimeClient(
time_controller_.get(), GetLogWriterFactory(name), config, stream_configs,
- send_link, return_link, send_id, return_id, Now());
+ send_link, return_link, send_ip, return_ip, Now());
if (log_writer_factory_ && !name.empty() &&
config.transport.state_log_interval.IsFinite()) {
Every(config.transport.state_log_interval, [this, client]() {
@@ -219,24 +219,24 @@
void Scenario::TriggerPacketBurst(std::vector<EmulatedNetworkNode*> over_nodes,
size_t num_packets,
size_t packet_size) {
- uint64_t route_id = next_route_id_++;
- EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_);
+ rtc::IPAddress route_ip(next_route_id_++);
+ EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, &null_receiver_);
for (size_t i = 0; i < num_packets; ++i)
over_nodes[0]->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress(), /*to*/
- route_id, rtc::CopyOnWriteBuffer(packet_size), Now()));
+ rtc::SocketAddress() /*from*/, rtc::SocketAddress(route_ip, 0) /*to*/,
+ rtc::CopyOnWriteBuffer(packet_size), Now()));
}
void Scenario::NetworkDelayedAction(
std::vector<EmulatedNetworkNode*> over_nodes,
size_t packet_size,
std::function<void()> action) {
- uint64_t route_id = next_route_id_++;
+ rtc::IPAddress route_ip(next_route_id_++);
action_receivers_.emplace_back(new ActionReceiver(action));
- EmulatedNetworkNode::CreateRoute(route_id, over_nodes,
+ EmulatedNetworkNode::CreateRoute(route_ip, over_nodes,
action_receivers_.back().get());
over_nodes[0]->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/, route_id,
+ rtc::SocketAddress() /*from*/, rtc::SocketAddress(route_ip, 0) /*to*/,
rtc::CopyOnWriteBuffer(packet_size), Now()));
}
@@ -251,11 +251,11 @@
CrossTrafficSource* Scenario::CreateCrossTraffic(
std::vector<EmulatedNetworkNode*> over_nodes,
CrossTrafficConfig config) {
- uint64_t route_id = next_route_id_++;
+ rtc::IPAddress route_ip(next_route_id_++);
cross_traffic_sources_.emplace_back(
- new CrossTrafficSource(over_nodes.front(), route_id, config));
+ new CrossTrafficSource(over_nodes.front(), route_ip, config));
CrossTrafficSource* node = cross_traffic_sources_.back().get();
- EmulatedNetworkNode::CreateRoute(route_id, over_nodes, &null_receiver_);
+ EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, &null_receiver_);
Every(config.min_packet_interval,
[this, node](TimeDelta delta) { node->Process(Now(), delta); });
return node;
diff --git a/test/scenario/simulated_time.cc b/test/scenario/simulated_time.cc
index efc0b72..f808c3a 100644
--- a/test/scenario/simulated_time.cc
+++ b/test/scenario/simulated_time.cc
@@ -112,8 +112,8 @@
}
SimulatedSender::SimulatedSender(EmulatedNetworkNode* send_node,
- uint64_t send_receiver_id)
- : send_node_(send_node), send_receiver_id_(send_receiver_id) {}
+ rtc::IPAddress send_receiver_ip)
+ : send_node_(send_node), send_receiver_address_(send_receiver_ip, 0) {}
SimulatedSender::~SimulatedSender() {}
@@ -203,10 +203,10 @@
}
SimulatedFeedback::SimulatedFeedback(SimulatedTimeClientConfig config,
- uint64_t return_receiver_id,
+ rtc::IPAddress return_receiver_ip,
EmulatedNetworkNode* return_node)
: config_(config),
- return_receiver_id_(return_receiver_id),
+ return_receiver_address_(return_receiver_ip, 0),
return_node_(return_node) {}
// Polls receiver side for a feedback report and sends it to the stream sender
@@ -231,14 +231,14 @@
if (report.receive_times.size() >=
RawFeedbackReportPacket::MAX_FEEDBACKS) {
return_node_->OnPacketReceived(
- EmulatedIpPacket(packet.to, packet.from, return_receiver_id_,
+ EmulatedIpPacket(packet.to, return_receiver_address_,
FeedbackToBuffer(report), packet.arrival_time));
report = SimpleFeedbackReportPacket();
}
}
if (!report.receive_times.empty())
return_node_->OnPacketReceived(
- EmulatedIpPacket(packet.to, packet.from, return_receiver_id_,
+ EmulatedIpPacket(packet.to, return_receiver_address_,
FeedbackToBuffer(report), packet.arrival_time));
last_feedback_time_ = packet.arrival_time;
}
@@ -251,8 +251,8 @@
std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link,
- uint64_t send_receiver_id,
- uint64_t return_receiver_id,
+ rtc::IPAddress send_receiver_ip,
+ rtc::IPAddress return_receiver_ip,
Timestamp at_time)
: log_writer_factory_(std::move(log_writer_factory)),
network_controller_factory_(time_controller,
@@ -260,8 +260,8 @@
config.transport),
send_link_(send_link),
return_link_(return_link),
- sender_(send_link.front(), send_receiver_id),
- feedback_(config, return_receiver_id, return_link.front()) {
+ sender_(send_link.front(), send_receiver_ip),
+ feedback_(config, return_receiver_ip, return_link.front()) {
current_contraints_.at_time = at_time;
current_contraints_.starting_rate = config.transport.rates.start_rate;
current_contraints_.min_data_rate = config.transport.rates.min_rate;
@@ -273,8 +273,8 @@
congestion_controller_ = network_controller_factory_.Create(initial_config);
for (auto& stream_config : stream_configs)
packet_streams_.emplace_back(new PacketStream(stream_config));
- EmulatedNetworkNode::CreateRoute(send_receiver_id, send_link, &feedback_);
- EmulatedNetworkNode::CreateRoute(return_receiver_id, return_link, this);
+ EmulatedNetworkNode::CreateRoute(send_receiver_ip, send_link, &feedback_);
+ EmulatedNetworkNode::CreateRoute(return_receiver_ip, return_link, this);
CongestionProcess(at_time);
network_controller_factory_.LogCongestionControllerStats(at_time);
@@ -331,8 +331,8 @@
ProcessFrames(at_time);
for (const auto& to_send : sender_.PaceAndPullSendPackets(at_time)) {
sender_.send_node_->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress() /*from*/, rtc::SocketAddress() /*to*/,
- sender_.send_receiver_id_, to_send.data, at_time));
+ rtc::SocketAddress() /*from*/, sender_.send_receiver_address_,
+ to_send.data, at_time));
Update(congestion_controller_->OnSentPacket(to_send.send_info));
}
}
diff --git a/test/scenario/simulated_time.h b/test/scenario/simulated_time.h
index 9214a8d..05ff887 100644
--- a/test/scenario/simulated_time.h
+++ b/test/scenario/simulated_time.h
@@ -50,7 +50,7 @@
class SimulatedFeedback : EmulatedNetworkReceiverInterface {
public:
SimulatedFeedback(SimulatedTimeClientConfig config,
- uint64_t return_receiver_id,
+ rtc::IPAddress return_receiver_ip,
EmulatedNetworkNode* return_node);
void OnPacketReceived(EmulatedIpPacket packet) override;
@@ -58,7 +58,7 @@
private:
friend class SimulatedTimeClient;
const SimulatedTimeClientConfig config_;
- const uint64_t return_receiver_id_;
+ const rtc::SocketAddress return_receiver_address_;
EmulatedNetworkNode* return_node_;
Timestamp last_feedback_time_ = Timestamp::MinusInfinity();
int32_t next_feedback_seq_num_ = 1;
@@ -88,7 +88,8 @@
int64_t size;
};
- SimulatedSender(EmulatedNetworkNode* send_node, uint64_t send_receiver_id);
+ SimulatedSender(EmulatedNetworkNode* send_node,
+ rtc::IPAddress send_receiver_ip);
SimulatedSender(const SimulatedSender&) = delete;
~SimulatedSender();
TransportPacketsFeedback PullFeedbackReport(SimpleFeedbackReportPacket report,
@@ -99,7 +100,7 @@
private:
friend class SimulatedTimeClient;
EmulatedNetworkNode* send_node_;
- uint64_t send_receiver_id_;
+ const rtc::SocketAddress send_receiver_address_;
PacerConfig pacer_config_;
DataSize max_in_flight_ = DataSize::Infinity();
@@ -127,8 +128,8 @@
std::vector<PacketStreamConfig> stream_configs,
std::vector<EmulatedNetworkNode*> send_link,
std::vector<EmulatedNetworkNode*> return_link,
- uint64_t send_receiver_id,
- uint64_t return_receiver_id,
+ rtc::IPAddress send_receiver_ip,
+ rtc::IPAddress return_receiver_ip,
Timestamp at_time);
SimulatedTimeClient(const SimulatedTimeClient&) = delete;
~SimulatedTimeClient();
