From 4cd433ed5f2cc0c4d4097bc79a3ca2d6daa9bc43 Mon Sep 17 00:00:00 2001 From: Artem Titov Date: Mon, 1 Apr 2019 11:01:16 +0200 Subject: [PATCH] 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 Reviewed-by: Sebastian Jansson Commit-Queue: Artem Titov Cr-Commit-Position: refs/heads/master@{#27386} --- test/scenario/call_client.cc | 8 +-- test/scenario/call_client.h | 2 +- test/scenario/network/network_emulation.cc | 56 ++++++++----------- test/scenario/network/network_emulation.h | 17 ++---- .../network/network_emulation_manager.cc | 14 ++--- test/scenario/network/traffic_route.cc | 2 +- test/scenario/network_node.cc | 34 ++++++----- test/scenario/network_node.h | 10 ++-- test/scenario/scenario.cc | 34 +++++------ test/scenario/simulated_time.cc | 28 +++++----- test/scenario/simulated_time.h | 13 +++-- 11 files changed, 107 insertions(+), 111 deletions(-) diff --git a/test/scenario/call_client.cc b/test/scenario/call_client.cc index 47da762069..a98c3e097a 100644 --- a/test/scenario/call_client.cc +++ b/test/scenario/call_client.cc @@ -195,10 +195,10 @@ Call::Stats CallClient::GetStats() { 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 14c283d874..c7ef65e9eb 100644 --- a/test/scenario/call_client.h +++ b/test/scenario/call_client.h @@ -112,7 +112,7 @@ class CallClient : public EmulatedNetworkReceiverInterface { std::unique_ptr fec_controller_factory_; // Stores the configured overhead per known destination endpoint. This is used // to subtract the overhead before processing. - std::map route_overhead_; + std::map 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 2021248143..03e2bf4d98 100644 --- a/test/scenario/network/network_emulation.cc +++ b/test/scenario/network/network_emulation.cc @@ -21,12 +21,10 @@ namespace webrtc { 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(EmulatedIpPacket&&) = default; EmulatedIpPacket& EmulatedIpPacket::operator=(EmulatedIpPacket&&) = default; void EmulatedNetworkNode::CreateRoute( - uint64_t receiver_id, + rtc::IPAddress receiver_ip, std::vector 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 nodes) { for (EmulatedNetworkNode* node : nodes) - node->RemoveReceiver(receiver_id); + node->RemoveReceiver(receiver_ip); } EmulatedNetworkNode::EmulatedNetworkNode( @@ -57,7 +55,7 @@ EmulatedNetworkNode::~EmulatedNetworkNode() = default; 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 @@ void EmulatedNetworkNode::Process(Timestamp at_time) { } 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::Process(Timestamp at_time) { } void EmulatedNetworkNode::SetReceiver( - uint64_t dest_endpoint_id, + rtc::IPAddress dest_ip, EmulatedNetworkReceiverInterface* receiver) { rtc::CritScope crit(&lock_); - RTC_CHECK(routing_ - .insert(std::pair( - 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 @@ EmulatedEndpoint::EmulatedEndpoint(uint64_t id, 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 @@ void EmulatedEndpoint::SendPacket(const rtc::SocketAddress& from, 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 EmulatedEndpoint::BindReceiver( @@ -228,9 +223,10 @@ rtc::IPAddress EmulatedEndpoint::GetPeerLocalAddress() const { } 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 @@ EmulatedNetworkNode* EmulatedEndpoint::GetSendNode() const { return send_node_; } -void EmulatedEndpoint::SetConnectedEndpointId(uint64_t endpoint_id) { - connected_endpoint_id_ = endpoint_id; -} - EndpointsContainer::EndpointsContainer( const std::vector& endpoints) : endpoints_(endpoints) {} @@ -279,8 +271,8 @@ EndpointsContainer::EndpointsContainer( 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 309d51163f..ec39dfeeab 100644 --- a/test/scenario/network/network_emulation.h +++ b/test/scenario/network/network_emulation.h @@ -43,7 +43,6 @@ struct EmulatedIpPacket { 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 @@ struct EmulatedIpPacket { rtc::SocketAddress from; rtc::SocketAddress to; - uint64_t dest_endpoint_id; rtc::CopyOnWriteBuffer data; Timestamp arrival_time; }; @@ -87,16 +85,16 @@ class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface { 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 nodes, EmulatedNetworkReceiverInterface* receiver); - static void ClearRoute(uint64_t receiver_id, + static void ClearRoute(rtc::IPAddress receiver_ip, std::vector nodes); private: @@ -107,7 +105,7 @@ class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface { }; rtc::CriticalSection lock_; - std::map routing_ + std::map routing_ RTC_GUARDED_BY(lock_); const std::unique_ptr network_behavior_ RTC_GUARDED_BY(lock_); @@ -170,7 +168,6 @@ class EmulatedEndpoint : public EmulatedNetworkReceiverInterface { friend class test::NetworkEmulationManagerImpl; EmulatedNetworkNode* GetSendNode() const; - void SetConnectedEndpointId(uint64_t endpoint_id); private: static constexpr uint16_t kFirstEphemeralPort = 49152; @@ -190,8 +187,6 @@ class EmulatedEndpoint : public EmulatedNetworkReceiverInterface { uint16_t next_port_ RTC_GUARDED_BY(receiver_lock_); std::map port_to_receiver_ RTC_GUARDED_BY(receiver_lock_); - - absl::optional connected_endpoint_id_; }; class EmulatedRoute { diff --git a/test/scenario/network/network_emulation_manager.cc b/test/scenario/network/network_emulation_manager.cc index 9c634eae0d..94b537336c 100644 --- a/test/scenario/network/network_emulation_manager.cc +++ b/test/scenario/network/network_emulation_manager.cc @@ -112,11 +112,10 @@ EmulatedRoute* NetworkEmulationManagerImpl::CreateRoute( 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 route = absl::make_unique(from, std::move(via_nodes), to); @@ -130,11 +129,12 @@ void NetworkEmulationManagerImpl::ClearRoute(EmulatedRoute* route) { // 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 @@ TrafficRoute* NetworkEmulationManagerImpl::CreateTrafficRoute( // 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 traffic_route = absl::make_unique(clock_, via_nodes[0], endpoint); diff --git a/test/scenario/network/traffic_route.cc b/test/scenario/network/traffic_route.cc index 8af767310b..6727a2421d 100644 --- a/test/scenario/network/traffic_route.cc +++ b/test/scenario/network/traffic_route.cc @@ -89,7 +89,7 @@ void TrafficRoute::SendPacket(size_t packet_size, uint16_t dest_port) { 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 a206a5f6ef..e0f8f8ecad 100644 --- a/test/scenario/network_node.cc +++ b/test/scenario/network_node.cc @@ -106,9 +106,8 @@ bool NetworkNodeTransport::SendRtp(const uint8_t* packet, 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 @@ bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) { 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::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(receiver_ip.v4AddressAsHostOrderInteger()); + route.remote_network_id = + static_cast(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 @@ void CrossTrafficSource::Process(Timestamp at_time, TimeDelta delta) { 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 bdaf2fe2be..71b7de97f8 100644 --- a/test/scenario/network_node.h +++ b/test/scenario/network_node.h @@ -75,7 +75,7 @@ class NetworkNodeTransport : public Transport { 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 @@ class NetworkNodeTransport : public Transport { 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 @@ class CrossTrafficSource { 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 09e70f0849..3e9fd402f4 100644 --- a/test/scenario/scenario.cc +++ b/test/scenario/scenario.cc @@ -155,10 +155,10 @@ void Scenario::ChangeRoute(std::pair clients, void Scenario::ChangeRoute(std::pair clients, std::vector 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 @@ SimulatedTimeClient* Scenario::CreateSimulatedTimeClient( std::vector stream_configs, std::vector send_link, std::vector 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 @@ EmulatedNetworkNode* Scenario::CreateNetworkNode( void Scenario::TriggerPacketBurst(std::vector 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 over_nodes, size_t packet_size, std::function 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( CrossTrafficSource* Scenario::CreateCrossTraffic( std::vector 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 efc0b72ab4..f808c3a004 100644 --- a/test/scenario/simulated_time.cc +++ b/test/scenario/simulated_time.cc @@ -112,8 +112,8 @@ rtc::CopyOnWriteBuffer FeedbackToBuffer( } 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 @@ void SimulatedSender::Update(NetworkControlUpdate update) { } 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 @@ void SimulatedFeedback::OnPacketReceived(EmulatedIpPacket packet) { 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 @@ SimulatedTimeClient::SimulatedTimeClient( std::vector stream_configs, std::vector send_link, std::vector 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 @@ SimulatedTimeClient::SimulatedTimeClient( 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 @@ SimulatedTimeClient::SimulatedTimeClient( 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 @@ void SimulatedTimeClient::PacerProcess(Timestamp at_time) { 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 9214a8dd59..05ff887f43 100644 --- a/test/scenario/simulated_time.h +++ b/test/scenario/simulated_time.h @@ -50,7 +50,7 @@ class PacketStream { 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 @@ class SimulatedFeedback : EmulatedNetworkReceiverInterface { 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 @@ class SimulatedSender { 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 @@ class SimulatedSender { 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 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface { std::vector stream_configs, std::vector send_link, std::vector 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();