diff options
Diffstat (limited to 'scripts/automation/trex_control_plane/client')
| -rw-r--r-- | scripts/automation/trex_control_plane/client/trex_stateless_client.py | 300 |
1 files changed, 182 insertions, 118 deletions
diff --git a/scripts/automation/trex_control_plane/client/trex_stateless_client.py b/scripts/automation/trex_control_plane/client/trex_stateless_client.py index 12f6eff6..b7580531 100644 --- a/scripts/automation/trex_control_plane/client/trex_stateless_client.py +++ b/scripts/automation/trex_control_plane/client/trex_stateless_client.py @@ -16,135 +16,66 @@ class CTRexStatelessClient(object): def __init__(self, server="localhost", port=5050, virtual=False): super(CTRexStatelessClient, self).__init__() self.tx_link = CTRexStatelessClient.CTxLink(server, port, virtual) + self._conn_handler = {} - def add_stream(self, handler, port_id, stream_id, stream_obj): - assert isinstance(stream_obj, CTRexStatelessClient.CStream) - params = {"handler":handler, + def owned(func): + def wrapper(self, *args, **kwargs ) : + if self._conn_handler.get(kwargs.get("port_id")): + return func(self, *args, **kwargs) + else: + raise RuntimeError("The requested method ('{0}') cannot be invoked unless the desired port is owned". + format(func.__name__)) + return wrapper + + def acquire(self, port_id, username, force=False): + params = {"port_id": port_id, + "user": username, + "force": force} + self._conn_handler[port_id] = self.transmit("acquire", params) + return self._conn_handler + + @owned + def release(self, port_id=None): + self._conn_handler.pop(port_id) + params = {"handler":self._conn_handler.get(port_id), + "port_id": port_id} + return self.transmit("release", params) + + @owned + def add_stream(self, stream_id, stream_obj, port_id=None): + assert isinstance(stream_obj, CStream) + params = {"handler":self._conn_handler.get(port_id), "port_id":port_id, "stream_id":stream_id, "stream":stream_obj.dump()} return self.transmit("add_stream", params) - def transmit(self, method_name, params={}): - return self.tx_link.transmit(method_name, params) + @owned + def remove_stream(self, stream_id, port_id=None): + params = {"handler":self._conn_handler.get(port_id), + "port_id":port_id, + "stream_id":stream_id} + return self.transmit("remove_stream", params) + @owned + def get_stream_list(self, port_id=None): + params = {"handler":self._conn_handler.get(port_id), + "port_id":port_id} + return self.transmit("get_stream_list", params) - # ------ private classes ------ # - class CStream(object): - """docstring for CStream""" - def __init__(self): - super(CTRexStatelessClient.CStream, self).__init__() - self.packet = CTRexPktBuilder() - self.rx_stats = CTRexStatelessClient.CRxStats() - self.mode = CTRexStatelessClient.CTxMode() - self.isg - self._next_stream = -1 - self._self_start - self._enabled - - @property - def enabled(self): - return self._enabled - - @enabled.setter - def enabled(self, bool_value): - self._enabled = bool(bool_value) - - @property - def self_start(self): - return self._self_start - - @self_start.setter - def self_start(self, bool_value): - self._self_start = bool(bool_value) - - @property - def next_stream(self): - return self._next_stream - - @next_stream.setter - def next_stream(self, value): - self._next_stream = int(bool_value) - - def dump(self): - pass - return {"enabled":self.enabled, - "self_start":self.self_start, - "isg":self.isg, - "next_stream":self.next_stream, - "packet":self.packet.dump_pkt(), - "mode":self.mode.dump(), - "vm":self.packet.dump_vm_instructions(), # TODO - add this method to packet builder module - "rx_stats":self.rx_stats.dump()} - - class CRxStats(object): - - def __init__(self, enabled=False, seq_enabled=False, latency_enabled=False): - self._rx_dict = {"enabled" : enabled, - "seq_enabled" : seq_enabled, - "latency_enabled" : latency_enabled} - - @property - def enabled(self): - return self._rx_dict.get("enabled") - - @enabled.setter - def enabled(self, bool_value): - self._rx_dict['enabled'] = bool(bool_value) - - @property - def seq_enabled(self): - return self._rx_dict.get("seq_enabled") - - @seq_enabled.setter - def seq_enabled(self, bool_value): - self._rx_dict['seq_enabled'] = bool(bool_value) - - @property - def latency_enabled(self): - return self._rx_dict.get("latency_enabled") - - @latency_enabled.setter - def latency_enabled(self, bool_value): - self._rx_dict['latency_enabled'] = bool(bool_value) - - def dump(self): - return {k:v - for k,v in self._rx_dict.items() - if v - } - - class CTxMode(object): - """docstring for CTxMode""" - def __init__(self, tx_mode, pps): - super(CTxMode, self).__init__() - if tx_mode not in ["continuous", "single_burst", "multi_burst"]: - raise ValueError("Unknown TX mode ('{0}')has been initialized.".format(tx_mode)) - self._tx_mode = tx_mode - self._fields = {'pps':float(pps)} - if tx_mode == "single_burst": - self._fields['total_pkts'] = 0 - elif tx_mode == "multi_burst": - self._fields['pkts_per_burst'] = 0 - self._fields['ibg'] = 0.0 - self._fields['count'] = 0 - else: - pass + @owned + def get_stream(self, stream_id, port_id=None): + params = {"handler":self._conn_handler.get(port_id), + "port_id":port_id} + return self.transmit("get_stream_list", params) - def set_tx_mode_attr(self, attr, val): - if attr in self._fields: - self._fields[attr] = type(self._fields.get(attr))(val) - else: - raise ValueError("The provided attribute ('{0}') is not a legal attribute in selected TX mode ('{1}')". - format(attr, self._tx_mode)) - def dump(self): - dump = {"type":self._tx_mode} - dump.update({k:v - for k, v in self._fields.items() - }) - return dump + def transmit(self, method_name, params={}): + return self.tx_link.transmit(method_name, params) + + + # ------ private classes ------ # class CTxLink(object): """describes the connectivity of the stateless client method""" def __init__(self, server="localhost", port=5050, virtual=False): @@ -167,7 +98,140 @@ class CTRexStatelessClient(object): else: return self.rpc_link.invoke_rpc_method(method_name, params) +class CStream(object): + """docstring for CStream""" + DEFAULTS = {"rx_stats": CRxStats, + "mode": CTxMode, + "isg": 5.0, + "next_stream": -1, + "self_start": True, + "enabled": True} + + def __init__(self, **kwargs): + super(CStream, self).__init__() + for k, v in kwargs.items(): + setattr(self, k, v) + # set default values to unset attributes, according to DEFAULTS dict + set_keys = set(kwargs.keys()) + keys_to_set = [x for x in self.DEFAULTS if x not in set_keys] + for key in keys_to_set: + default = self.DEFAULTS.get(key) + if type(default)==type: + setattr(self, key, default()) + else: + setattr(self, key, default) + + @property + def packet(self): + return self._packet + + @packet.setter + def packet(self, packet_obj): + assert isinstance(packet_obj, CTRexPktBuilder) + self._packet = packet_obj + + @property + def enabled(self): + return self._enabled + + @enabled.setter + def enabled(self, bool_value): + self._enabled = bool(bool_value) + + @property + def self_start(self): + return self._self_start + + @self_start.setter + def self_start(self, bool_value): + self._self_start = bool(bool_value) + + @property + def next_stream(self): + return self._next_stream + + @next_stream.setter + def next_stream(self, value): + self._next_stream = int(value) + + def dump(self): + pass + return {"enabled":self.enabled, + "self_start":self.self_start, + "isg":self.isg, + "next_stream":self.next_stream, + "packet":self.packet.dump_pkt(), + "mode":self.mode.dump(), + "vm":self.packet.get_vm_data(), + "rx_stats":self.rx_stats.dump()} + +class CRxStats(object): + + def __init__(self, enabled=False, seq_enabled=False, latency_enabled=False): + self._rx_dict = {"enabled" : enabled, + "seq_enabled" : seq_enabled, + "latency_enabled" : latency_enabled} + + @property + def enabled(self): + return self._rx_dict.get("enabled") + + @enabled.setter + def enabled(self, bool_value): + self._rx_dict['enabled'] = bool(bool_value) + + @property + def seq_enabled(self): + return self._rx_dict.get("seq_enabled") + + @seq_enabled.setter + def seq_enabled(self, bool_value): + self._rx_dict['seq_enabled'] = bool(bool_value) + + @property + def latency_enabled(self): + return self._rx_dict.get("latency_enabled") + + @latency_enabled.setter + def latency_enabled(self, bool_value): + self._rx_dict['latency_enabled'] = bool(bool_value) + + def dump(self): + return {k:v + for k,v in self._rx_dict.items() + if v + } + +class CTxMode(object): + """docstring for CTxMode""" + def __init__(self, tx_mode, pps): + super(CTxMode, self).__init__() + if tx_mode not in ["continuous", "single_burst", "multi_burst"]: + raise ValueError("Unknown TX mode ('{0}')has been initialized.".format(tx_mode)) + self._tx_mode = tx_mode + self._fields = {'pps':float(pps)} + if tx_mode == "single_burst": + self._fields['total_pkts'] = 0 + elif tx_mode == "multi_burst": + self._fields['pkts_per_burst'] = 0 + self._fields['ibg'] = 0.0 + self._fields['count'] = 0 + else: + pass + def set_tx_mode_attr(self, attr, val): + if attr in self._fields: + self._fields[attr] = type(self._fields.get(attr))(val) + else: + raise ValueError("The provided attribute ('{0}') is not a legal attribute in selected TX mode ('{1}')". + format(attr, self._tx_mode)) + + def dump(self): + dump = {"type":self._tx_mode} + dump.update({k:v + for k, v in self._fields.items() + }) + return dump if __name__ == "__main__": |