Commiting last night progress

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__":