zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch routing from dest endpoint id to dest ip in network emulation layer

Browse Source 
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}
This commit is contained in:
Artem Titov
2019-04-01 11:01:16 +02:00
committed by Commit Bot
parent 359fe33163
commit 4cd433ed5f
11 changed files with 107 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/scenario/call_client.cc
View File

@ -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())) {

2
test/scenario/call_client.h
View File

@ -112,7 +112,7 @@ class CallClient : public EmulatedNetworkReceiverInterface {
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;

56
test/scenario/network/network_emulation.cc
View File

@ -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<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 @@ 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<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 @@ 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<uint16_t> 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<EmulatedEndpoint*>& 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;
}
}

17
test/scenario/network/network_emulation.h
View File

@ -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<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 @@ class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface {
};
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 @@ 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<uint16_t, EmulatedNetworkReceiverInterface*> port_to_receiver_
RTC_GUARDED_BY(receiver_lock_);
absl::optional<uint64_t> connected_endpoint_id_;
};
class EmulatedRoute {

14
test/scenario/network/network_emulation_manager.cc
View File

@ -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<EmulatedRoute> route =
absl::make_unique<EmulatedRoute>(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<TrafficRoute> traffic_route =
absl::make_unique<TrafficRoute>(clock_, via_nodes[0], endpoint);

2
test/scenario/network/traffic_route.cc
View File

@ -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())));
}

34
test/scenario/network_node.cc
View File

@ -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<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 @@ 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();
}
}

10
test/scenario/network_node.h
View File

@ -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_;

34
test/scenario/scenario.cc
View File

@ -155,10 +155,10 @@ void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
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 @@ SimulatedTimeClient* Scenario::CreateSimulatedTimeClient(
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 @@ EmulatedNetworkNode* Scenario::CreateNetworkNode(
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(
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;

28
test/scenario/simulated_time.cc
View File

@ -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<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 @@ 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));
}
}

13
test/scenario/simulated_time.h
View File

@ -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<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();