admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Using EmulatedEndpoint in Scenario tests.

Browse Source 
Bug: webrtc:9883
Change-Id: I7d1dc9d8efbdddc14e1fbe08d7b6a71c4bbe24ae
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/166341
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30300}
This commit is contained in:
Sebastian Jansson 2020-01-17 13:05:54 +01:00 committed by Commit Bot
parent 524417f3f7
commit 77bd385b55
9 changed files with 54 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
api/test/network_emulation/network_emulation_interfaces.h
View File

@ -99,7 +99,8 @@ class EmulatedEndpoint : public EmulatedNetworkReceiverInterface {
// on destination endpoint.
virtual void SendPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data) = 0;
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead = 0) = 0;
// Binds receiver to this endpoint to send and receive data.
// |desired_port| is a port that should be used. If it is equal to 0,

5
test/network/network_emulation.cc
View File

@ -203,10 +203,11 @@ uint64_t EmulatedEndpointImpl::GetId() const {
void EmulatedEndpointImpl::SendPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data) {
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead) {
RTC_CHECK(from.ipaddr() == peer_local_addr_);
EmulatedIpPacket packet(from, to, std::move(packet_data),
clock_->CurrentTime());
clock_->CurrentTime(), application_overhead);
task_queue_->PostTask([this, packet = std::move(packet)]() mutable {
RTC_DCHECK_RUN_ON(task_queue_);
Timestamp current_time = clock_->CurrentTime();

3
test/network/network_emulation.h
View File

@ -140,7 +140,8 @@ class EmulatedEndpointImpl : public EmulatedEndpoint {
void SendPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data) override;
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead = 0) override;
absl::optional<uint16_t> BindReceiver(
uint16_t desired_port,

11
test/scenario/call_client.cc
View File

@ -318,6 +318,17 @@ void CallClient::SendTask(std::function<void()> task) {
task_queue_.SendTask(std::move(task), RTC_FROM_HERE);
}
int16_t CallClient::Bind(EmulatedEndpoint* endpoint) {
uint16_t port = endpoint->BindReceiver(0, this).value();
endpoints_.push_back({endpoint, port});
return port;
}
void CallClient::UnBind() {
for (auto ep_port : endpoints_)
ep_port.first->UnbindReceiver(ep_port.second);
}
CallClientPair::~CallClientPair() = default;
} // namespace test

3
test/scenario/call_client.h
View File

@ -130,6 +130,8 @@ class CallClient : public EmulatedNetworkReceiverInterface {
uint32_t GetNextRtxSsrc();
void AddExtensions(std::vector<RtpExtension> extensions);
void SendTask(std::function<void()> task);
int16_t Bind(EmulatedEndpoint* endpoint);
void UnBind();
TimeController* const time_controller_;
Clock* clock_;
@ -140,6 +142,7 @@ class CallClient : public EmulatedNetworkReceiverInterface {
std::unique_ptr<Call> call_;
std::unique_ptr<NetworkNodeTransport> transport_;
std::unique_ptr<RtpHeaderParser> const header_parser_;
std::vector<std::pair<EmulatedEndpoint*, uint16_t>> endpoints_;
int next_video_ssrc_index_ = 0;
int next_video_local_ssrc_index_ = 0;

44
test/scenario/network_node.cc
View File

@ -85,48 +85,42 @@ bool NetworkNodeTransport::SendRtp(const uint8_t* packet,
sent_packet.info.packet_type = rtc::PacketType::kData;
sender_call_->OnSentPacket(sent_packet);
Timestamp send_time = Timestamp::ms(send_time_ms);
rtc::CritScope crit(&crit_sect_);
if (!send_net_)
if (!endpoint_)
return false;
rtc::CopyOnWriteBuffer buffer(packet, length);
send_net_->OnPacketReceived(
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time,
packet_overhead_.bytes()));
endpoint_->SendPacket(local_address_, remote_address_, buffer,
packet_overhead_.bytes());
return true;
}
bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) {
rtc::CopyOnWriteBuffer buffer(packet, length);
Timestamp send_time = sender_clock_->CurrentTime();
rtc::CritScope crit(&crit_sect_);
if (!send_net_)
if (!endpoint_)
return false;
send_net_->OnPacketReceived(
EmulatedIpPacket(local_address_, receiver_address_, buffer, send_time,
packet_overhead_.bytes()));
endpoint_->SendPacket(local_address_, remote_address_, buffer,
packet_overhead_.bytes());
return true;
}
void NetworkNodeTransport::Connect(EmulatedNetworkNode* send_node,
const rtc::IPAddress& receiver_ip,
void NetworkNodeTransport::Connect(EmulatedEndpoint* endpoint,
const rtc::SocketAddress& receiver_address,
DataSize packet_overhead) {
rtc::NetworkRoute route;
route.connected = true;
route.local_network_id =
static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
route.remote_network_id =
static_cast<uint16_t>(receiver_ip.v4AddressAsHostOrderInteger());
// We assume that the address will be unique in the lower bytes.
route.local_network_id = static_cast<uint16_t>(
receiver_address.ipaddr().v4AddressAsHostOrderInteger());
route.remote_network_id = static_cast<uint16_t>(
receiver_address.ipaddr().v4AddressAsHostOrderInteger());
{
// 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());
// Only IPv4 address is supported.
RTC_CHECK_EQ(receiver_address.family(), AF_INET);
rtc::CritScope crit(&crit_sect_);
send_net_ = send_node;
receiver_address_ = rtc::SocketAddress(receiver_ip, 0);
endpoint_ = endpoint;
local_address_ = rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), 0);
remote_address_ = receiver_address;
packet_overhead_ = packet_overhead;
current_network_route_ = route;
}
@ -141,7 +135,7 @@ void NetworkNodeTransport::Disconnect() {
sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged(
kDummyTransportName, current_network_route_);
current_network_route_ = {};
send_net_ = nullptr;
endpoint_ = nullptr;
}
} // namespace test

11
test/scenario/network_node.h
View File

@ -59,8 +59,8 @@ class NetworkNodeTransport : public Transport {
const PacketOptions& options) override;
bool SendRtcp(const uint8_t* packet, size_t length) override;
void Connect(EmulatedNetworkNode* send_node,
const rtc::IPAddress& receiver_ip,
void Connect(EmulatedEndpoint* endpoint,
const rtc::SocketAddress& receiver_address,
DataSize packet_overhead);
void Disconnect();
@ -73,10 +73,9 @@ 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;
rtc::SocketAddress receiver_address_ RTC_GUARDED_BY(crit_sect_);
EmulatedEndpoint* endpoint_ RTC_GUARDED_BY(crit_sect_) = nullptr;
rtc::SocketAddress local_address_ RTC_GUARDED_BY(crit_sect_);
rtc::SocketAddress remote_address_ RTC_GUARDED_BY(crit_sect_);
DataSize packet_overhead_ RTC_GUARDED_BY(crit_sect_) = DataSize::Zero();
rtc::NetworkRoute current_network_route_ RTC_GUARDED_BY(crit_sect_);
};

13
test/scenario/scenario.cc
View File

@ -75,10 +75,10 @@ Scenario::Scenario(
bool real_time)
: log_writer_factory_(std::move(log_writer_factory)),
time_controller_(CreateTimeController(real_time)),
network_manager_(time_controller_.get()),
clock_(time_controller_->GetClock()),
audio_decoder_factory_(CreateBuiltinAudioDecoderFactory()),
audio_encoder_factory_(CreateBuiltinAudioEncoderFactory()),
network_manager_(time_controller_.get()),
task_queue_(time_controller_->GetTaskQueueFactory()->CreateTaskQueue(
"Scenario",
TaskQueueFactory::Priority::NORMAL)) {}
@ -86,8 +86,10 @@ Scenario::Scenario(
Scenario::~Scenario() {
if (start_time_.IsFinite())
Stop();
for (auto& call_client : clients_)
for (auto& call_client : clients_) {
call_client->transport_->Disconnect();
call_client->UnBind();
}
}
ColumnPrinter Scenario::TimePrinter() {
@ -165,9 +167,10 @@ void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
std::vector<EmulatedNetworkNode*> over_nodes,
DataSize overhead) {
rtc::IPAddress route_ip(next_route_id_++);
EmulatedNetworkNode::CreateRoute(route_ip, over_nodes, clients.second);
clients.first->transport_->Connect(over_nodes.front(), route_ip, overhead);
EmulatedRoute* route = network_manager_.CreateRoute(over_nodes);
uint16_t port = clients.second->Bind(route->to);
auto addr = rtc::SocketAddress(route->to->GetPeerLocalAddress(), port);
clients.first->transport_->Connect(route->from, addr, overhead);
}
EmulatedNetworkNode* Scenario::CreateSimulationNode(

3
test/scenario/scenario.h
View File

@ -162,6 +162,7 @@ class Scenario {
const std::unique_ptr<LogWriterFactoryInterface> log_writer_factory_;
std::unique_ptr<TimeController> time_controller_;
NetworkEmulationManagerImpl network_manager_;
Clock* clock_;
std::vector<std::unique_ptr<CallClient>> clients_;
@ -171,12 +172,10 @@ class Scenario {
std::vector<std::unique_ptr<SimulationNode>> simulation_nodes_;
std::vector<std::unique_ptr<StatesPrinter>> printers_;
int64_t next_route_id_ = 40000;
rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory_;
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
Timestamp start_time_ = Timestamp::PlusInfinity();
NetworkEmulationManagerImpl network_manager_;
// Defined last so it's destroyed first.
rtc::TaskQueue task_queue_;
};