aboutsummaryrefslogtreecommitdiffstats
path: root/core/traffic_controller_rfc2889.py
blob: a97a47d3e107637bde95da1d24ff45180a3efac0 (plain)
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