aboutsummaryrefslogtreecommitdiffstats
path: root/resources
diff options
context:
space:
mode:
Diffstat (limited to 'resources')
-rw-r--r--resources/libraries/python/DropRateSearch.py301
-rw-r--r--resources/libraries/python/TrafficGenerator.py165
-rwxr-xr-xresources/tools/t-rex/t-rex-stateless.py2
3 files changed, 407 insertions, 61 deletions
diff --git a/resources/libraries/python/DropRateSearch.py b/resources/libraries/python/DropRateSearch.py
new file mode 100644
index 0000000000..4bbf16c1a2
--- /dev/null
+++ b/resources/libraries/python/DropRateSearch.py
@@ -0,0 +1,301 @@
+# Copyright (c) 2016 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.
+
+"""Drop rate search algorithms"""
+
+from abc import ABCMeta, abstractmethod
+from enum import Enum, unique
+
+@unique
+class SearchDirection(Enum):
+ """Direction of linear search"""
+
+ TOP_DOWN = 1
+ BOTTOM_UP = 2
+
+@unique
+class SearchResults(Enum):
+ """Result of the drop rate search"""
+
+ SUCCESS = 1
+ FAILURE = 2
+ SUSPICIOUS = 3
+
+@unique
+class RateType(Enum):
+ """Type of rate units"""
+
+ PERCENTAGE = 1
+ PACKETS_PER_SECOND = 2
+ BITS_PER_SECOND = 3
+
+@unique
+class LossAcceptanceType(Enum):
+ """Type of the loss acceptance criteria"""
+
+ FRAMES = 1
+ PERCENTAGE = 2
+
+class DropRateSearch(object):
+ """Abstract class with search algorithm implementation"""
+
+ __metaclass__ = ABCMeta
+
+ def __init__(self):
+ #duration of traffic run (binary, linear)
+ self._duration = 60
+ #initial start rate (binary, linear)
+ self._rate_start = 100
+ #step of the linear search, unit: RateType (self._rate_type)
+ self._rate_linear_step = 10
+ #linear search direction, permitted values: SearchDirection
+ self._search_linear_direction = SearchDirection.TOP_DOWN
+ #upper limit of search, unit: RateType (self._rate_type)
+ self._rate_max = 100
+ #lower limit of search, unit: RateType (self._rate_type)
+ self._rate_min = 1
+ #permitted values: RateType
+ self._rate_type = RateType.PERCENTAGE
+ #accepted loss during search, units: LossAcceptanceType
+ self._loss_acceptance = 0
+ #permitted values: LossAcceptanceType
+ self._loss_acceptance_type = LossAcceptanceType.FRAMES
+ #size of frames to send
+ self._frame_size = "64"
+ #binary convergence criterium type is self._rate_type
+ self._binary_convergence_threshhold = "0.01"
+ #numbers of traffic runs during one rate step
+ self._max_attempts = 1
+
+ #result of search
+ self._search_result = None
+ self._search_result_rate = None
+
+ @abstractmethod
+ def measure_loss(self, rate, frame_size, loss_acceptance,
+ loss_acceptance_type, traffic_type):
+ """Send traffic from TG and measure count of dropped frames
+
+ :param rate: offered traffic load
+ :param frame_size: size of frame
+ :param loss_acceptance: permitted drop ratio or frames count
+ :param loss_acceptance_type: type of permitted loss
+ :param traffic_type: traffic profile ([2,3]-node-L[2,3], ...)
+ :type rate: int
+ :type frame_size: str
+ :type loss_acceptance: float
+ :type loss_acceptance_type: LossAcceptanceType
+ :type traffic_type: str
+ :return: drop threshhold exceeded? (True/False)
+ :rtype bool
+ """
+ pass
+
+ def set_search_rate_boundaries(self, max_rate, min_rate):
+ """Set search boundaries: min,max
+
+ :param max_rate: upper value of search boundaries
+ :param min_rate: lower value of search boundaries
+ :type max_rate: float
+ :type min_rate: float
+ :return: nothing
+ """
+ if float(min_rate) <= 0:
+ raise ValueError("min_rate must be higher than 0")
+ elif float(min_rate) > float(max_rate):
+ raise ValueError("min_rate must be lower than max_rate")
+ else:
+ self._rate_max = float(max_rate)
+ self._rate_min = float(min_rate)
+
+ def set_search_linear_step(self, step_rate):
+ """Set step size for linear search
+
+ :param step_rate: linear search step size
+ :type step_rate: float
+ :return: nothing
+ """
+ self._rate_linear_step = float(step_rate)
+
+ def set_search_rate_type_percentage(self):
+ """Set rate type to percentage of linerate
+
+ :return: nothing
+ """
+ self._set_search_rate_type(RateType.PERCENTAGE)
+
+ def set_search_rate_type_bps(self):
+ """Set rate type to bits per second
+
+ :return: nothing
+ """
+ self._set_search_rate_type(RateType.BITS_PER_SECOND)
+
+ def set_search_rate_type_pps(self):
+ """Set rate type to packets per second
+
+ :return: nothing
+ """
+ self._set_search_rate_type(RateType.PACKETS_PER_SECOND)
+
+ def _set_search_rate_type(self, rate_type):
+ """Set rate type to one of RateType-s
+
+ :param rate_type: type of rate to set
+ :type rate_type: RateType
+ :return: nothing
+ """
+ if rate_type not in RateType:
+ raise Exception("rate_type unknown: {}".format(rate_type))
+ else:
+ self._rate_type = rate_type
+
+ def set_search_frame_size(self, frame_size):
+ """Set size of frames to send
+
+ :param frame_size: size of frames
+ :type frame_size: str
+ :return: nothing
+ """
+ self._frame_size = frame_size
+
+ def set_duration(self, duration):
+ """Set the duration of single traffic run
+
+ :param duration: number of seconds for traffic to run
+ :type duration: int
+ :return: nothing
+ """
+ self._duration = int(duration)
+
+ def get_duration(self):
+ """Return configured duration of single traffic run
+
+ :return: number of seconds for traffic to run
+ :rtype: int
+ """
+ return self._duration
+
+ def get_rate_type_str(self):
+ """Return rate type representation
+
+ :return: string representation of rate type
+ :rtype: str
+ """
+ if self._rate_type == RateType.PERCENTAGE:
+ return "%"
+ elif self._rate_type == RateType.BITS_PER_SECOND:
+ return "bps"
+ elif self._rate_type == RateType.PACKETS_PER_SECOND:
+ return "pps"
+ else:
+ raise ValueError("RateType unknown")
+
+ def linear_search(self, start_rate, traffic_type):
+ """Linear search of rate with loss below acceptance criteria
+
+ :param start_rate: initial rate
+ :param traffic_type: traffic profile
+ :type start_rate: float
+ :param traffic_type: str
+ :return: nothing
+ """
+
+ if not self._rate_min <= float(start_rate) <= self._rate_max:
+ raise ValueError("Start rate is not in min,max range")
+
+ rate = float(start_rate)
+ #the last but one step
+ prev_rate = None
+
+ #linear search
+ while True:
+ res = self.measure_loss(rate, self._frame_size,
+ self._loss_acceptance,
+ self._loss_acceptance_type,
+ traffic_type)
+ if self._search_linear_direction == SearchDirection.BOTTOM_UP:
+ #loss occured and it was above acceptance criteria
+ if res == False:
+ #if this is first run then we didn't find drop rate
+ if prev_rate == None:
+ self._search_result = SearchResults.FAILURE
+ self._search_result_rate = None
+ return
+ # else we found the rate, which is value from previous run
+ else:
+ self._search_result = SearchResults.SUCCESS
+ self._search_result_rate = prev_rate
+ return
+ #there was no loss / loss below acceptance criteria
+ elif res == True:
+ prev_rate = rate
+ rate += self._rate_linear_step
+ if rate > self._rate_max:
+ if prev_rate != self._rate_max:
+ #one last step with rate set to _rate_max
+ rate = self._rate_max
+ continue
+ else:
+ self._search_result = SearchResults.SUCCESS
+ self._search_result_rate = prev_rate
+ return
+ else:
+ continue
+ else:
+ raise RuntimeError("Unknown search result")
+
+ elif self._search_linear_direction == SearchDirection.TOP_DOWN:
+ #loss occured, decrease rate
+ if res == False:
+ prev_rate = rate
+ rate -= self._rate_linear_step
+ if rate < self._rate_min:
+ if prev_rate != self._rate_min:
+ #one last step with rate set to _rate_min
+ rate = self._rate_min
+ continue
+ else:
+ self._search_result = SearchResults.FAILURE
+ self._search_result_rate = None
+ return
+ else:
+ continue
+ #no loss => non/partial drop rate found
+ elif res == True:
+ self._search_result = SearchResults.SUCCESS
+ self._search_result_rate = rate
+ return
+ else:
+ raise RuntimeError("Unknown search result")
+ else:
+ raise Exception("Unknown search direction")
+
+ raise Exception("Wrong codepath")
+
+ def verify_search_result(self):
+ """Fail if search was not successful
+
+ :return: result rate
+ :rtype: float
+ """
+ if self._search_result == SearchResults.FAILURE:
+ raise Exception('Search FAILED')
+ elif self._search_result in [SearchResults.SUCCESS, SearchResults.SUSPICIOUS]:
+ return self._search_result_rate
+
+ def binary_search(self):
+ raise NotImplementedError
+
+ def combined_search(self):
+ raise NotImplementedError
diff --git a/resources/libraries/python/TrafficGenerator.py b/resources/libraries/python/TrafficGenerator.py
index fb9ae4db1c..c3af0863be 100644
--- a/resources/libraries/python/TrafficGenerator.py
+++ b/resources/libraries/python/TrafficGenerator.py
@@ -14,17 +14,50 @@
"""Performance testing traffic generator library."""
from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+from robot.api.deco import keyword
from resources.libraries.python.ssh import SSH
from resources.libraries.python.topology import NodeType
from resources.libraries.python.topology import NodeSubTypeTG
from resources.libraries.python.topology import Topology
+from resources.libraries.python.DropRateSearch import DropRateSearch
-__all__ = ['TrafficGenerator']
+__all__ = ['TrafficGenerator', 'TGDropRateSearchImpl']
+
+class TGDropRateSearchImpl(DropRateSearch):
+ """Drop Rate Search implementation"""
+
+ def __init__(self):
+ super(TGDropRateSearchImpl, self).__init__()
+
+ def measure_loss(self, rate, frame_size, loss_acceptance,
+ loss_acceptance_type, traffic_type):
+
+ #we need instance of TrafficGenerator instantiated by Robot Framework
+ #to be able to use trex_stateless_remote_exec method
+ tg_instance = BuiltIn().get_library_instance('resources.libraries.python.TrafficGenerator')
+
+ if tg_instance._node['subtype'] is None:
+ raise Exception('TG subtype not defined')
+ elif tg_instance._node['subtype'] == NodeSubTypeTG.TREX:
+ unit_rate = str(rate) + self.get_rate_type_str()
+ tg_instance.trex_stateless_remote_exec(self.get_duration(), unit_rate,
+ frame_size, traffic_type)
+
+ #TODO:getters for tg_instance and loss_acceptance_type
+ logger.trace("comparing: {} < {} ".format(tg_instance._loss, loss_acceptance))
+ if float(tg_instance._loss) > float(loss_acceptance):
+ return False
+ else:
+ return True
+ else:
+ raise NotImplementedError("TG subtype not supported")
class TrafficGenerator(object):
"""Traffic Generator"""
+ #use one instance of TrafficGenerator for all tests in test suite
ROBOT_LIBRARY_SCOPE = 'TEST SUITE'
def __init__(self):
@@ -32,6 +65,7 @@ class TrafficGenerator(object):
self._loss = None
self._sent = None
self._received = None
+ self._node = None
#T-REX interface order mapping
self._ifaces_reordered = 0
@@ -69,6 +103,8 @@ class TrafficGenerator(object):
if tg_node['type'] != NodeType.TG:
raise Exception('Node type is not a TG')
+ self._node = tg_node
+
if tg_node['subtype'] == NodeSubTypeTG.TREX:
ssh = SSH()
ssh.connect(tg_node)
@@ -103,6 +139,7 @@ class TrafficGenerator(object):
"- port_limit : 2\n"
" version : 2\n"
" interfaces : [\"{}\",\"{}\"]\n"
+ " port_bandwidth_gb : 10\n"
" port_info :\n"
" - dest_mac : [{}]\n"
" src_mac : [{}]\n"
@@ -152,16 +189,76 @@ class TrafficGenerator(object):
logger.error('pkill t-rex failed: {0}'.format(stdout + stderr))
raise RuntimeError('pkill t-rex failed')
- def send_traffic_on(self, nodes_info, duration, rate,
+ def trex_stateless_remote_exec(self, duration, rate, framesize,
+ traffic_type):
+ """Execute stateless script on remote node over ssh
+
+ :param node: remote node
+ :param traffic_type: Traffic profile
+ :type node: dict
+ :type traffic_type: str
+ """
+ ssh = SSH()
+ ssh.connect(self._node)
+
+ _p0 = 1
+ _p1 = 2
+
+ if self._ifaces_reordered != 0:
+ _p0, _p1 = _p1, _p0
+
+ if traffic_type in ["3-node-xconnect", "3-node-bridge"]:
+ (ret, stdout, stderr) = ssh.exec_command(
+ "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/"
+ "t-rex-stateless.py "
+ "-d {0} -r {1} -s {2} "
+ "--p{3}_src_start_ip 10.10.10.1 "
+ "--p{3}_src_end_ip 10.10.10.254 "
+ "--p{3}_dst_start_ip 20.20.20.1 "
+ "--p{4}_src_start_ip 20.20.20.1 "
+ "--p{4}_src_end_ip 20.20.20.254 "
+ "--p{4}_dst_start_ip 10.10.10.1'".\
+ format(duration, rate, framesize, _p0, _p1),\
+ timeout=int(duration)+60)
+ elif traffic_type in ["3-node-IPv4"]:
+ (ret, stdout, stderr) = ssh.exec_command(
+ "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/"
+ "t-rex-stateless.py "
+ "-d {0} -r {1} -s {2} "
+ "--p{3}_src_start_ip 10.10.10.2 "
+ "--p{3}_src_end_ip 10.10.10.254 "
+ "--p{3}_dst_start_ip 20.20.20.2 "
+ "--p{4}_src_start_ip 20.20.20.2 "
+ "--p{4}_src_end_ip 20.20.20.254 "
+ "--p{4}_dst_start_ip 10.10.10.2'".\
+ format(duration, rate, framesize, _p0, _p1),\
+ timeout=int(duration)+60)
+ else:
+ raise NotImplementedError('Unsupported traffic type')
+
+ logger.trace(ret)
+ logger.trace(stdout)
+ logger.trace(stderr)
+
+ #last line from console output
+ line = stdout.splitlines()[-1]
+
+ self._result = line
+ logger.info('TrafficGen result: {0}'.format(self._result))
+
+ self._received = self._result.split(', ')[1].split('=')[1]
+ self._sent = self._result.split(', ')[2].split('=')[1]
+ self._loss = self._result.split(', ')[3].split('=')[1]
+
+ def send_traffic_on(self, node, duration, rate,
framesize, traffic_type):
"""Send traffic from all configured interfaces on TG
- :param nodes_info: Dictionary containing information on all nodes
- in topology.
+ :param node: Dictionary containing TG information
:param duration: Duration of test traffic generation in seconds
:param rate: Offered load per interface (e.g. 1%, 3gbps, 4mpps, ...)
:param framesize: Frame size (L2) in Bytes
:param traffic_type: Traffic profile
- :type nodes_info: dict
+ :type node: dict
:type duration: str
:type rate: str
:type framesize: str
@@ -170,69 +267,17 @@ class TrafficGenerator(object):
:rtype: str
"""
- node = nodes_info["TG"]
-
if node['type'] != NodeType.TG:
raise Exception('Node type is not a TG')
if node['subtype'] is None:
raise Exception('TG subtype not defined')
-
- ssh = SSH()
- ssh.connect(node)
-
- if node['subtype'] == NodeSubTypeTG.TREX:
-
- _p0 = 1
- _p1 = 2
-
- if self._ifaces_reordered != 0:
- _p0, _p1 = _p1, _p0
-
- if traffic_type in ["3-node-xconnect", "3-node-bridge"]:
- (ret, stdout, stderr) = ssh.exec_command(
- "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/"
- "t-rex-stateless.py "
- "-d {0} -r {1} -s {2} "
- "--p{3}_src_start_ip 10.10.10.1 "
- "--p{3}_src_end_ip 10.10.10.254 "
- "--p{3}_dst_start_ip 20.20.20.1 "
- "--p{4}_src_start_ip 20.20.20.1 "
- "--p{4}_src_end_ip 20.20.20.254 "
- "--p{4}_dst_start_ip 10.10.10.1'".\
- format(duration, rate, framesize, _p0, _p1),\
- timeout=int(duration)+60)
- elif traffic_type in ["3-node-IPv4"]:
- (ret, stdout, stderr) = ssh.exec_command(
- "sh -c '/tmp/openvpp-testing/resources/tools/t-rex/"
- "t-rex-stateless.py "
- "-d {0} -r {1} -s {2} "
- "--p{3}_src_start_ip 10.10.10.2 "
- "--p{3}_src_end_ip 10.10.10.254 "
- "--p{3}_dst_start_ip 20.20.20.2 "
- "--p{4}_src_start_ip 20.20.20.2 "
- "--p{4}_src_end_ip 20.20.20.254 "
- "--p{4}_dst_start_ip 10.10.10.2'".\
- format(duration, rate, framesize, _p0, _p1),\
- timeout=int(duration)+60)
- else:
- raise NotImplementedError('Unsupported traffic type')
-
+ elif node['subtype'] == NodeSubTypeTG.TREX:
+ self.trex_stateless_remote_exec(duration, rate, framesize,
+ traffic_type)
else:
raise NotImplementedError("TG subtype not supported")
- logger.trace(ret)
- logger.trace(stdout)
- logger.trace(stderr)
-
- for line in stdout.splitlines():
- pass
-
- self._result = line
- logger.info('TrafficGen result: {0}'.format(self._result))
-
- self._loss = self._result.split(', ')[3].split('=')[1]
-
return self._result
def no_traffic_loss_occured(self):
diff --git a/resources/tools/t-rex/t-rex-stateless.py b/resources/tools/t-rex/t-rex-stateless.py
index 6c53794739..46c67cc829 100755
--- a/resources/tools/t-rex/t-rex-stateless.py
+++ b/resources/tools/t-rex/t-rex-stateless.py
@@ -158,7 +158,7 @@ def simple_burst(pkt_a, pkt_b, duration=10, rate="1mpps",
c.start(ports=[0, 1], mult=rate, duration=duration)
# block until done
- c.wait_on_traffic(ports=[0, 1])
+ c.wait_on_traffic(ports=[0, 1], timeout=(duration+30))
# read the stats after the test
stats = c.get_stats()