1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
"""RFC2889 Traffic Controller implementation.
"""
import logging
from core.traffic_controller import ITrafficController
from core.results.results_constants import ResultsConstants
from core.results.results import IResults
from conf import settings
from conf import get_test_param
class TrafficControllerRFC2889(ITrafficController, IResults):
"""Traffic controller for RFC2889 traffic
Used to setup and control a traffic generator for an RFC2889 deployment
traffic scenario.
"""
def __init__(self, traffic_gen_class):
"""Initialise the trafficgen and store.
:param traffic_gen_class: The traffic generator class to be used.
"""
self._logger = logging.getLogger(__name__)
self._logger.debug("__init__")
self._traffic_gen_class = traffic_gen_class()
self._traffic_started = False
self._traffic_started_call_count = 0
self._trials = int(get_test_param('rfc2889_trials', 1))
self._duration = int(get_test_param('duration', 30))
self._results = []
# If set, comma separated packet_sizes value from --test_params
# on cli takes precedence over value in settings file.
self._packet_sizes = None
packet_sizes_cli = get_test_param('pkt_sizes')
if packet_sizes_cli:
self._packet_sizes = [int(x.strip())
for x in packet_sizes_cli.split(',')]
else:
self._packet_sizes = settings.getValue('TRAFFICGEN_PKT_SIZES')
def __enter__(self):
"""Call initialisation function.
"""
self._traffic_gen_class.connect()
def __exit__(self, type_, value, traceback):
"""Stop traffic, clean up.
"""
if self._traffic_started:
self.stop_traffic()
@staticmethod
def _append_results(result_dict, packet_size):
"""Adds common values to traffic generator results.
:param result_dict: Dictionary containing results from trafficgen
:param packet_size: Packet size value.
:returns: dictionary of results with additional entries.
"""
ret_value = result_dict
ret_value[ResultsConstants.TYPE] = 'rfc2889'
ret_value[ResultsConstants.PACKET_SIZE] = str(packet_size)
return ret_value
def send_traffic(self, traffic):
"""See ITrafficController for description
"""
self._logger.debug('send_traffic with ' +
str(self._traffic_gen_class))
for packet_size in self._packet_sizes:
# Merge framesize with the default traffic definition
if 'l2' in traffic:
traffic['l2'] = dict(traffic['l2'],
**{'framesize': packet_size})
else:
traffic['l2'] = {'framesize': packet_size}
if traffic['traffic_type'] == 'caching':
result = self._traffic_gen_class.send_rfc2889_caching(
traffic, trials=self._trials, duration=self._duration)
elif traffic['traffic_type'] == 'congestion':
result = self._traffic_gen_class.send_rfc2889_congestion(
traffic, duration=self._duration)
else:
result = self._traffic_gen_class.send_rfc2889_forwarding(
traffic, tests=self._trials, duration=self._duration)
result = TrafficControllerRFC2889._append_results(result,
packet_size)
self._results.append(result)
def send_traffic_async(self, traffic, function):
"""See ITrafficController for description
"""
self._logger.debug('send_traffic_async with ' +
str(self._traffic_gen_class))
for packet_size in self._packet_sizes:
traffic['l2'] = {'framesize': packet_size}
self._traffic_gen_class.start_rfc2889_forwarding(
traffic,
trials=self._trials,
duration=self._duration)
self._traffic_started = True
if len(function['args']) > 0:
function['function'](function['args'])
else:
function['function']()
result = self._traffic_gen_class.wait_rfc2889_forwarding(
traffic, trials=self._trials, duration=self._duration)
result = TrafficControllerRFC2889._append_results(result,
packet_size)
self._results.append(result)
def stop_traffic(self):
"""Kills traffic being sent from the traffic generator.
"""
self._logger.debug("stop_traffic()")
def print_results(self):
"""IResult interface implementation.
"""
counter = 0
for item in self._results:
logging.info("Record: " + str(counter))
counter += 1
for(key, value) in list(item.items()):
logging.info(" Key: " + str(key) +
", Value: " + str(value))
def get_results(self):
"""IResult interface implementation.
"""
return self._results
def validate_send_traffic(self, result, traffic):
"""Verify that send traffic has succeeded
"""
return True
|
