read only support

8 files changed, 222 insertions, 131 deletions

diff --git a/src/publisher/trex_publisher.h b/src/publisher/trex_publisher.h
index 8d1be064..bd4392f7 100644
--- a/src/publisher/trex_publisher.h
+++ b/src/publisher/trex_publisher.h
@@ -39,10 +39,16 @@ public:
     void publish_json(const std::string &s);
 
     enum event_type_e {
-        EVENT_PORT_STARTED       = 0,
-        EVENT_PORT_STOPPED       = 1,
-        EVENT_SERVER_STOPPED     = 2,
-        EVENT_PORT_FINISHED_TX   = 3,
+        EVENT_PORT_STARTED          = 0,
+        EVENT_PORT_STOPPED          = 1,
+        EVENT_PORT_PAUSED           = 2,
+        EVENT_PORT_RESUMED          = 3,
+        EVENT_PORT_FINISHED_TX      = 4,
+        EVENT_PORT_FORCE_ACQUIRED   = 5,
+
+        EVENT_SERVER_STOPPED        = 100,
+        
+        
     };
 
     void publish_event(event_type_e type, const Json::Value &data = Json::nullValue);
diff --git a/src/rpc-server/commands/trex_rpc_cmd_general.cpp b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
index 5cea055c..6c239bf3 100644
--- a/src/rpc-server/commands/trex_rpc_cmd_general.cpp
+++ b/src/rpc-server/commands/trex_rpc_cmd_general.cpp
@@ -198,10 +198,6 @@ TrexRpcCmdGetSysInfo::_run(const Json::Value &params, Json::Value &result) {
         }
 
 
-        section["ports"][i]["owner"] = port->get_owner();
-
-        section["ports"][i]["status"] = port->get_state_as_string();
-
     }
 
     return (TREX_RPC_CMD_OK);
@@ -224,7 +220,7 @@ TrexRpcCmdGetOwner::_run(const Json::Value &params, Json::Value &result) {
     uint8_t port_id = parse_port(params, result);
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
-    section["owner"] = port->get_owner();
+    section["owner"] = port->get_owner().get_name();
 
     return (TREX_RPC_CMD_OK);
 }
@@ -238,19 +234,20 @@ TrexRpcCmdAcquire::_run(const Json::Value &params, Json::Value &result) {
 
     uint8_t port_id = parse_port(params, result);
 
-    const string &new_owner = parse_string(params, "user", result);
+    const string  &new_owner  = parse_string(params, "user", result);
+    uint32_t      session_id  = parse_uint32(params, "session_id", result);
     bool force = parse_bool(params, "force", result);
 
     /* if not free and not you and not force - fail */
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
     try {
-        port->acquire(new_owner, force);
+        port->acquire(new_owner, session_id, force);
     } catch (const TrexRpcException &ex) {
         generate_execute_err(result, ex.what());
     }
 
-    result["result"] = port->get_owner_handler();
+    result["result"] = port->get_owner().get_handler();
 
     return (TREX_RPC_CMD_OK);
 }
@@ -288,8 +285,6 @@ TrexRpcCmdGetPortStats::_run(const Json::Value &params, Json::Value &result) {
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-    result["result"]["status"] = port->get_state_as_string();
-
     try {
         port->encode_stats(result["result"]);
     } catch (const TrexRpcException &ex) {
@@ -300,41 +295,25 @@ TrexRpcCmdGetPortStats::_run(const Json::Value &params, Json::Value &result) {
 }
 
 /**
- * request the server a sync about a specific user
+ * fetch the port status
+ * 
+ * @author imarom (09-Dec-15)
+ * 
+ * @param params 
+ * @param result 
  * 
+ * @return trex_rpc_cmd_rc_e 
  */
 trex_rpc_cmd_rc_e
-TrexRpcCmdSyncUser::_run(const Json::Value &params, Json::Value &result) {
-
-    const string &user = parse_string(params, "user", result);
-    bool sync_streams = parse_bool(params, "sync_streams", result);
-
-    result["result"] = Json::arrayValue;
-
-    for (auto port : get_stateless_obj()->get_port_list()) {
-        if (port->get_owner() == user) {
-
-            Json::Value owned_port;
+TrexRpcCmdGetPortStatus::_run(const Json::Value &params, Json::Value &result) {
+    uint8_t port_id = parse_port(params, result);
 
-            owned_port["port_id"] = port->get_port_id();
-            owned_port["handler"] = port->get_owner_handler();
-            owned_port["state"]   = port->get_state_as_string();
-            
-            /* if sync streams was asked - sync all the streams */
-            if (sync_streams) {
-                owned_port["streams"] = Json::arrayValue;
+    TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-                std::vector <TrexStream *> streams;
-                port->get_object_list(streams);
+    result["result"]["owner"]  = (port->get_owner().is_free() ? "" : port->get_owner().get_name());
+    result["result"]["state"] = port->get_state_as_string();
 
-                for (auto stream : streams) {
-                    owned_port["streams"].append(stream->get_stream_json());
-                }
-            }
-
-            result["result"].append(owned_port);
-        }
-    }
 
     return (TREX_RPC_CMD_OK);
 }
+
diff --git a/src/rpc-server/commands/trex_rpc_cmds.h b/src/rpc-server/commands/trex_rpc_cmds.h
index 80bef3b0..b9be1fbe 100644
--- a/src/rpc-server/commands/trex_rpc_cmds.h
+++ b/src/rpc-server/commands/trex_rpc_cmds.h
@@ -70,14 +70,15 @@ void get_hostname(std::string &hostname);
  * ownership
  */
 TREX_RPC_CMD_DEFINE(TrexRpcCmdGetOwner,   "get_owner",       1, false);
-TREX_RPC_CMD_DEFINE(TrexRpcCmdAcquire,    "acquire",         3, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdAcquire,    "acquire",         4, false);
 TREX_RPC_CMD_DEFINE(TrexRpcCmdRelease,    "release",         1, true);
 
 
 /**
  * port commands
  */
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStatus, "get_port_status", 1, false);
 
 
 /**
@@ -98,10 +99,10 @@ void parse_vm_instr_write_flow_var(const Json::Value &inst, TrexStream *stream,
 );
 
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, true);
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, false);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, false);
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, true);
+TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, false);
 
 
 
@@ -112,8 +113,6 @@ TREX_RPC_CMD_DEFINE(TrexRpcCmdResumeTraffic, "resume_traffic", 1, true);
 
 TREX_RPC_CMD_DEFINE(TrexRpcCmdUpdateTraffic, "update_traffic", 2, true);
 
-TREX_RPC_CMD_DEFINE(TrexRpcCmdSyncUser, "sync_user", 2, false);
-
 TREX_RPC_CMD_DEFINE(TrexRpcCmdValidate, "validate", 2, false);
 
 #endif /* __TREX_RPC_CMD_H__ */
diff --git a/src/rpc-server/trex_rpc_cmd.cpp b/src/rpc-server/trex_rpc_cmd.cpp
index af0db3f4..d4eef1f7 100644
--- a/src/rpc-server/trex_rpc_cmd.cpp
+++ b/src/rpc-server/trex_rpc_cmd.cpp
@@ -63,8 +63,12 @@ TrexRpcCommand::verify_ownership(const Json::Value &params, Json::Value &result)
 
     TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
 
-    if (!port->verify_owner_handler(handler)) {
-        generate_execute_err(result, "invalid handler provided. please pass the handler given when calling 'acquire' or take ownership");
+    if (port->get_owner().is_free()) {
+        generate_execute_err(result, "please acquire the port before modifying port state");
+    }
+
+    if (!port->get_owner().verify(handler)) {
+        generate_execute_err(result, "port is not owned by you or your current executing session");
     }
 }
 
@@ -92,6 +96,8 @@ TrexRpcCommand::type_to_str(field_type_e type) {
         return "byte";
     case FIELD_TYPE_UINT16:
         return "uint16";
+    case FIELD_TYPE_UINT32:
+        return "uint32";
     case FIELD_TYPE_BOOL:
         return "bool";
     case FIELD_TYPE_INT:
@@ -161,6 +167,18 @@ TrexRpcCommand::parse_uint16(const Json::Value &parent, int index, Json::Value &
     return parent[index].asUInt();
 }
 
+uint32_t 
+TrexRpcCommand::parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result) {
+    check_field_type(parent, name, FIELD_TYPE_UINT32, result);
+    return parent[name].asUInt();
+}
+
+uint32_t  
+TrexRpcCommand::parse_uint32(const Json::Value &parent, int index, Json::Value &result) {
+    check_field_type(parent, index, FIELD_TYPE_UINT32, result);
+    return parent[index].asUInt();
+}
+
 int
 TrexRpcCommand::parse_int(const Json::Value &parent, const std::string &name, Json::Value &result) {
     check_field_type(parent, name, FIELD_TYPE_INT, result);
@@ -250,6 +268,12 @@ TrexRpcCommand::check_field_type_common(const Json::Value &field, const std::str
         }
         break;
 
+    case FIELD_TYPE_UINT32:
+        if ( (!field.isUInt()) || (field.asUInt() > 0xFFFFFFFF)) {
+            rc = false;
+        }
+        break;
+
     case FIELD_TYPE_BOOL:
         if (!field.isBool()) {
             rc = false;
diff --git a/src/rpc-server/trex_rpc_cmd_api.h b/src/rpc-server/trex_rpc_cmd_api.h
index e93fb775..f81981d4 100644
--- a/src/rpc-server/trex_rpc_cmd_api.h
+++ b/src/rpc-server/trex_rpc_cmd_api.h
@@ -99,6 +99,7 @@ protected:
     enum field_type_e {
         FIELD_TYPE_BYTE,
         FIELD_TYPE_UINT16,
+        FIELD_TYPE_UINT32,
         FIELD_TYPE_INT,
         FIELD_TYPE_DOUBLE,
         FIELD_TYPE_BOOL,
@@ -136,6 +137,7 @@ protected:
      */
     uint8_t  parse_byte(const Json::Value &parent, const std::string &name, Json::Value &result);
     uint16_t parse_uint16(const Json::Value &parent, const std::string &name, Json::Value &result);
+    uint32_t parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result);
     int      parse_int(const Json::Value &parent, const std::string &name, Json::Value &result);
     double   parse_double(const Json::Value &parent, const std::string &name, Json::Value &result);
     bool     parse_bool(const Json::Value &parent, const std::string &name, Json::Value &result);
@@ -145,6 +147,7 @@ protected:
 
     uint8_t  parse_byte(const Json::Value &parent, int index, Json::Value &result);
     uint16_t parse_uint16(const Json::Value &parent, int index, Json::Value &result);
+    uint32_t parse_uint32(const Json::Value &parent, int index, Json::Value &result);
     int      parse_int(const Json::Value &parent, int index, Json::Value &result);
     double   parse_double(const Json::Value &parent, int index, Json::Value &result);
     bool     parse_bool(const Json::Value &parent, int index, Json::Value &result);
diff --git a/src/rpc-server/trex_rpc_cmds_table.cpp b/src/rpc-server/trex_rpc_cmds_table.cpp
index 52258b88..82c723b7 100644
--- a/src/rpc-server/trex_rpc_cmds_table.cpp
+++ b/src/rpc-server/trex_rpc_cmds_table.cpp
@@ -41,8 +41,8 @@ TrexRpcCommandsTable::TrexRpcCommandsTable() {
     register_command(new TrexRpcCmdAcquire());
     register_command(new TrexRpcCmdRelease());
     register_command(new TrexRpcCmdGetPortStats());
-
-    register_command(new TrexRpcCmdSyncUser());
+    register_command(new TrexRpcCmdGetPortStatus());
+    
 
     /* stream commands */
     register_command(new TrexRpcCmdAddStream());
diff --git a/src/stateless/cp/trex_stateless_port.cpp b/src/stateless/cp/trex_stateless_port.cpp
index 0e45bf0b..96194321 100644
--- a/src/stateless/cp/trex_stateless_port.cpp
+++ b/src/stateless/cp/trex_stateless_port.cpp
@@ -57,7 +57,6 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api
 
     m_port_id = port_id;
     m_port_state = PORT_STATE_IDLE;
-    clear_owner();
 
     /* get the platform specific data */
     api->get_interface_info(port_id, m_driver_name, m_speed);
@@ -85,18 +84,42 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api
  * @param force 
  */
 void 
-TrexStatelessPort::acquire(const std::string &user, bool force) {
-    if ( (!is_free_to_aquire()) && (get_owner() != user) && (!force)) {
-        throw TrexRpcException("port is already taken by '" + get_owner() + "'");
+TrexStatelessPort::acquire(const std::string &user, uint32_t session_id, bool force) {
+
+    /* if port is free - just take it */
+    if (get_owner().is_free()) {
+        get_owner().own(user, session_id);
+        return;
+    }
+
+    /* not free - but it might be the same user that owns the port */
+    if ( (get_owner().get_name() == user) && (get_owner().get_session_id() == session_id) ) {
+        return;
+    }
+
+    /* so different session id or different user */
+    if (force) {
+        get_owner().own(user, session_id);
+
+        /* inform the other client of the steal... */
+        Json::Value data;
+        data["port_id"] = m_port_id;
+        get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_FORCE_ACQUIRED, data);
+
+    } else {
+        /* not same user or session id and not force - report error */
+        if (get_owner().get_name() == user) {
+            throw TrexRpcException("port is already owned by another session of '" + user + "'");
+        } else {
+            throw TrexRpcException("port is already taken by '" + get_owner().get_name() + "'");
+        }
     }
 
-    set_owner(user);
 }
 
 void
 TrexStatelessPort::release(void) {
-    verify_state( ~(PORT_STATE_TX | PORT_STATE_PAUSE) );
-    clear_owner();
+    get_owner().release();
 }
 
 /**
@@ -221,6 +244,10 @@ TrexStatelessPort::pause_traffic(void) {
     send_message_to_all_dp(pause_msg);
 
     change_state(PORT_STATE_PAUSE);
+
+    Json::Value data;
+    data["port_id"] = m_port_id;
+    get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_PAUSED, data);
 }
 
 void
@@ -234,6 +261,11 @@ TrexStatelessPort::resume_traffic(void) {
     send_message_to_all_dp(resume_msg);
 
     change_state(PORT_STATE_TX);
+
+
+    Json::Value data;
+    data["port_id"] = m_port_id;
+    get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_RESUMED, data);
 }
 
 void
@@ -324,27 +356,6 @@ TrexStatelessPort::change_state(port_state_e new_state) {
     m_port_state = new_state;
 }
 
-/**
- * generate a random connection handler
- * 
- */
-std::string 
-TrexStatelessPort::generate_handler() {
-    std::stringstream ss;
-
-    static const char alphanum[] =
-        "0123456789"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-        "abcdefghijklmnopqrstuvwxyz";
-
-    /* generate 8 bytes of random handler */
-    for (int i = 0; i < 8; ++i) {
-        ss << alphanum[rand() % (sizeof(alphanum) - 1)];
-    }
-
-    return (ss.str());
-}
-
 
 void
 TrexStatelessPort::encode_stats(Json::Value &port) {
@@ -576,3 +587,37 @@ TrexStatelessPort::validate(void) {
 
     return m_graph_obj;
 }
+
+
+/************* Trex Port Owner **************/
+
+TrexPortOwner::TrexPortOwner() {
+    m_is_free = true;
+
+    /* for handlers random generation */
+    srand(time(NULL));
+}
+
+/**
+ * generate a random connection handler
+ * 
+ */
+std::string 
+TrexPortOwner::generate_handler() {
+    std::stringstream ss;
+
+    static const char alphanum[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+
+    /* generate 8 bytes of random handler */
+    for (int i = 0; i < 8; ++i) {
+        ss << alphanum[rand() % (sizeof(alphanum) - 1)];
+    }
+
+    return (ss.str());
+}
+
+const std::string TrexPortOwner::g_unowned_name = "<FREE>";
+const std::string TrexPortOwner::g_unowned_handler = "";
diff --git a/src/stateless/cp/trex_stateless_port.h b/src/stateless/cp/trex_stateless_port.h
index 28e42a17..1310fdb2 100644
--- a/src/stateless/cp/trex_stateless_port.h
+++ b/src/stateless/cp/trex_stateless_port.h
@@ -29,6 +29,82 @@ class TrexStatelessCpToDpMsgBase;
 class TrexStreamsGraphObj;
 class TrexPortMultiplier;
 
+/** 
+ * TRex port owner can perform
+ * write commands
+ * while port is owned - others can
+ * do read only commands
+ * 
+ */
+class TrexPortOwner {
+public:
+
+    TrexPortOwner();
+
+    /**
+     * is port free to acquire
+     */
+    bool is_free() {
+        return m_is_free;
+    }
+
+    void release() {
+        m_is_free = true;
+        m_owner_name = "";
+        m_handler = "";
+    }
+
+    bool is_owned_by(const std::string &user) {
+        return ( !m_is_free && (m_owner_name == user) );
+    }
+
+    void own(const std::string &owner_name, uint32_t session_id) {
+
+        /* save user data */
+        m_owner_name = owner_name;
+        m_session_id = session_id;
+
+        /* internal data */
+        m_handler = generate_handler();
+        m_is_free = false;
+    }
+
+    bool verify(const std::string &handler) {
+        return ( (!m_is_free) && (m_handler == handler) );
+    }
+
+    const std::string &get_name() {
+        return (!m_is_free ? m_owner_name : g_unowned_name);
+    }
+
+    const std::string &get_handler() {
+        return (!m_is_free ? m_handler : g_unowned_handler);
+    }
+
+    uint32_t get_session_id() {
+        return m_session_id;
+    }
+
+private:
+    std::string  generate_handler();
+
+    /* is this port owned by someone ? */
+    bool         m_is_free;
+
+    /* user provided info - name and session id */
+    std::string  m_owner_name;
+    uint32_t     m_session_id;
+
+    /* handler genereated internally */
+    std::string  m_handler;
+    
+
+    /* just references defaults... */
+    static const std::string g_unowned_name;
+    static const std::string g_unowned_handler;
+};
+
+
 /**
  * describes a stateless port
  * 
@@ -67,7 +143,7 @@ public:
      * acquire port
      * throws TrexException in case of an error
      */
-    void acquire(const std::string &user, bool force = false);
+    void acquire(const std::string &user, uint32_t session_id, bool force = false);
 
     /**
      * release the port from the current user
@@ -140,29 +216,6 @@ public:
     void get_properties(std::string &driver, TrexPlatformApi::driver_speed_e &speed);
 
 
-    /**
-    * query for ownership
-    * 
-    */
-    const std::string &get_owner() {
-        return m_owner;
-    }
-
-    /**
-     * owner handler 
-     * for the connection 
-     * 
-     */
-    const std::string &get_owner_handler() {
-        return m_owner_handler;
-    }
-
-
-    bool verify_owner_handler(const std::string &handler) {
-
-        return ( (m_owner != "none") && (m_owner_handler == handler) );
-
-    }
 
     /**
      * encode stats as JSON
@@ -246,29 +299,11 @@ public:
      */
     uint64_t get_port_speed_bps() const;
 
-private:
-
-  
-
-    /**
-    * take ownership of the server array 
-    * this is static 
-    * ownership is total 
-    * 
-    */
-    void set_owner(const std::string &owner) {
-        m_owner = owner;
-        m_owner_handler = generate_handler();
-    }
-
-    void clear_owner() {
-        m_owner = "none";
-        m_owner_handler = "";
+    TrexPortOwner & get_owner() {
+        return m_owner;
     }
 
-    bool is_free_to_aquire() {
-        return (m_owner == "none");
-    }
+private:
 
 
     const std::vector<int> get_core_id_list () {
@@ -325,14 +360,12 @@ private:
     TrexStreamTable    m_stream_table;
     uint8_t            m_port_id;
     port_state_e       m_port_state;
-    std::string        m_owner;
-    std::string        m_owner_handler;
     std::string        m_driver_name;
 
     TrexPlatformApi::driver_speed_e m_speed;
 
     /* holds the DP cores associated with this port */
-    std::vector<int> m_cores_id_list;
+    std::vector<int>   m_cores_id_list;
 
     bool               m_last_all_streams_continues;
     double             m_last_duration;
@@ -342,8 +375,10 @@ private:
 
     /* holds a graph of streams rate*/
     const TrexStreamsGraphObj  *m_graph_obj;
-};
 
+    /* owner information */
+    TrexPortOwner       m_owner;
+};
 
 
 /**