From b3f5b759d051e8f12ee72a70d8b170a8d94a29d3 Mon Sep 17 00:00:00 2001 From: Jan Gelety Date: Tue, 4 Aug 2020 23:48:36 +0200 Subject: Perf: NAT44 endpoint-dependent mode - tcp, part I Jira: CSIT-1736 - tcp synthetic profiles w/o data packets - tcp cps perf tests, phase I (no special "search cps" KW) Change-Id: I52be34b0fdd51d7a33c8c5de9b46d7064c48f7fa Signed-off-by: Jan Gelety --- .../trex/trex-astf-ethip4tcp-1024h.py | 120 +++++++++++++++++++++ .../trex/trex-astf-ethip4tcp-16384h.py | 120 +++++++++++++++++++++ .../trex/trex-astf-ethip4tcp-262144h.py | 120 +++++++++++++++++++++ .../trex/trex-astf-ethip4tcp-4096h.py | 120 +++++++++++++++++++++ .../trex/trex-astf-ethip4tcp-65536h.py | 120 +++++++++++++++++++++ .../trex/trex-astf-ethip4udp-1024h.py | 4 + .../trex/trex-astf-ethip4udp-16384h.py | 4 + .../trex/trex-astf-ethip4udp-262144h.py | 4 + .../trex/trex-astf-ethip4udp-4096h.py | 4 + .../trex/trex-astf-ethip4udp-65536h.py | 4 + 10 files changed, 620 insertions(+) create mode 100644 GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py create mode 100644 GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py create mode 100644 GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py create mode 100644 GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py create mode 100644 GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py (limited to 'GPL') diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py new file mode 100644 index 0000000000..809a954a30 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py @@ -0,0 +1,120 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.3.255 + - Destination IP address range: 20.0.0.0 - 20.0.3.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.3.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.3.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + + # Delay for keeping tcp sessions active + self.delay = 2000000 # delay 2s (2,000,000 usec) + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + # send syn + prog_c.connect() + # receive syn-ack (0B sent in tcp syn-ack packet) and send ack + prog_c.recv(0) + # wait defined time, then send fin-ack + prog_c.delay(self.delay) + + # server commands + prog_s = ASTFProgram() + # receive syn, send syn-ack + prog_s.accept() + # receive fin-ack, send ack + fin-ack + prog_s.wait_for_peer_close() + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=64512, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py new file mode 100644 index 0000000000..0d7f9a5974 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py @@ -0,0 +1,120 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.63.255 + - Destination IP address range: 20.0.0.0 - 20.0.63.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.63.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.63.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + + # Delay for keeping tcp sessions active + self.delay = 2000000 # delay 2s (2,000,000 usec) + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + # send syn + prog_c.connect() + # receive syn-ack (0B sent in tcp syn-ack packet) and send ack + prog_c.recv(0) + # wait defined time, then send fin-ack + prog_c.delay(self.delay) + + # server commands + prog_s = ASTFProgram() + # receive syn, send syn-ack + prog_s.accept() + # receive fin-ack, send ack + fin-ack + prog_s.wait_for_peer_close() + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=1032192, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py new file mode 100644 index 0000000000..6f533844e0 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py @@ -0,0 +1,120 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 172.16.0.0 - 172.19.255.255 + - Destination IP address range: 20.16.0.0 - 20.19.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"172.16.0.0" + self.p1_src_end_ip = u"172.19.255.255" + self.p1_dst_start_ip = u"20.16.0.0" + self.p1_dst_end_ip = u"20.19.255.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + + # Delay for keeping tcp sessions active + self.delay = 2000000 # delay 2s (2,000,000 usec) + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + # send syn + prog_c.connect() + # receive syn-ack (0B sent in tcp syn-ack packet) and send ack + prog_c.recv(0) + # wait defined time, then send fin-ack + prog_c.delay(self.delay) + + # server commands + prog_s = ASTFProgram() + # receive syn, send syn-ack + prog_s.accept() + # receive fin-ack, send ack + fin-ack + prog_s.wait_for_peer_close() + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=16515072, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py new file mode 100644 index 0000000000..acfc5e109a --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py @@ -0,0 +1,120 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.15.255 + - Destination IP address range: 20.0.0.0 - 20.0.15.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.15.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.15.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + + # Delay for keeping tcp sessions active + self.delay = 2000000 # delay 2s (2,000,000 usec) + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + # send syn + prog_c.connect() + # receive syn-ack (0B sent in tcp syn-ack packet) and send ack + prog_c.recv(0) + # wait defined time, then send fin-ack + prog_c.delay(self.delay) + + # server commands + prog_s = ASTFProgram() + # receive syn, send syn-ack + prog_s.accept() + # receive fin-ack, send ack + fin-ack + prog_s.wait_for_peer_close() + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=258048, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py new file mode 100644 index 0000000000..7d2f5b6265 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py @@ -0,0 +1,120 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.255.255 + - Destination IP address range: 20.0.0.0 - 20.0.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.255.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.255.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + + # Delay for keeping tcp sessions active + self.delay = 2000000 # delay 2s (2,000,000 usec) + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + # send syn + prog_c.connect() + # receive syn-ack (0B sent in tcp syn-ack packet) and send ack + prog_c.recv(0) + # wait defined time, then send fin-ack + prog_c.delay(self.delay) + + # server commands + prog_s = ASTFProgram() + # receive syn, send syn-ack + prog_s.accept() + # receive fin-ack, send ack + fin-ack + prog_s.wait_for_peer_close() + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=4128768, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py index c2a004bc52..6bf0d53d1f 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py @@ -78,6 +78,8 @@ class TrafficProfile(TrafficProfileBaseClass): # receive RES message prog_c.recv_msg(1) + prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # server commands prog_s = ASTFProgram(stream=False) # set the keepalive timer for UDP flows to not close udp session @@ -88,6 +90,8 @@ class TrafficProfile(TrafficProfileBaseClass): # send RES message prog_s.send_msg(self.udp_res) + prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # ip generators ip_gen_c = ASTFIPGenDist( ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py index bf1ac295e7..9237831aa5 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py @@ -78,6 +78,8 @@ class TrafficProfile(TrafficProfileBaseClass): # receive RES message prog_c.recv_msg(1) + prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # server commands prog_s = ASTFProgram(stream=False) # set the keepalive timer for UDP flows to not close udp session @@ -88,6 +90,8 @@ class TrafficProfile(TrafficProfileBaseClass): # send RES message prog_s.send_msg(self.udp_res) + prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # ip generators ip_gen_c = ASTFIPGenDist( ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py index 43ca0cba48..728eba8a04 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py @@ -78,6 +78,8 @@ class TrafficProfile(TrafficProfileBaseClass): # receive RES message prog_c.recv_msg(1) + prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # server commands prog_s = ASTFProgram(stream=False) # set the keepalive timer for UDP flows to not close udp session @@ -88,6 +90,8 @@ class TrafficProfile(TrafficProfileBaseClass): # send RES message prog_s.send_msg(self.udp_res) + prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # ip generators ip_gen_c = ASTFIPGenDist( ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py index ff26b3bdaa..0807175d36 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py @@ -78,6 +78,8 @@ class TrafficProfile(TrafficProfileBaseClass): # receive RES message prog_c.recv_msg(1) + prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # server commands prog_s = ASTFProgram(stream=False) # set the keepalive timer for UDP flows to not close udp session @@ -88,6 +90,8 @@ class TrafficProfile(TrafficProfileBaseClass): # send RES message prog_s.send_msg(self.udp_res) + prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # ip generators ip_gen_c = ASTFIPGenDist( ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py index b6324f34fe..85eaff005c 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py @@ -78,6 +78,8 @@ class TrafficProfile(TrafficProfileBaseClass): # receive RES message prog_c.recv_msg(1) + prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # server commands prog_s = ASTFProgram(stream=False) # set the keepalive timer for UDP flows to not close udp session @@ -88,6 +90,8 @@ class TrafficProfile(TrafficProfileBaseClass): # send RES message prog_s.send_msg(self.udp_res) + prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # ip generators ip_gen_c = ASTFIPGenDist( ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], -- cgit 1.2.3-korg