Refactor the session manager using session transformation 2D array & Update test case

src/session/session_transition.cpp

@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <assert.h>
+
+#include "session_transition.h"
+
+#define MAX_TRANSITION_PER_STATE 4
+
+struct session_transition
+{
+    int inputs_mask;
+    enum session_state next_state;
+} fsm[MAX_STATE][MAX_TRANSITION_PER_STATE];
+
+/*
+ * session transition
+ *
+ *   SESSION_STATE_INIT    -> SESSION_STATE_INIT            ( NONE )
+ *   SESSION_STATE_INIT    -> SESSION_STATE_OPENING         ( TCP_SYN | TCP_SYN_ACK | UDP_DATA )
+ *
+ *   SESSION_STATE_OPENING -> SESSION_STATE_OPENING         ( NONE )
+ *   SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE          ( TCP_DATA | UDP_DATA )
+ *   SESSION_STATE_OPENING -> SESSION_STATE_CLOSING         ( TCP_FIN | TCP_RST | TIMEOUT )
+ *   SESSION_STATE_OPENING -> SESSION_STATE_CLOSED          ( LRU_EVICT )
+ *
+ *   SESSION_STATE_ACTIVE  -> SESSION_STATE_ACTIVE          ( NONE )
+ *   SESSION_STATE_ACTIVE  -> SESSION_STATE_CLOSING         ( TCP_FIN | TCP_RST | TIMEOUT )
+ *   SESSION_STATE_ACTIVE  -> SESSION_STATE_CLOSED          ( LRU_EVICT )
+ *
+ *   SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING         ( NONE )
+ *   SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED          ( TIMEOUT | LRU_EVICT )
+ */
+
+static void session_inputs_to_str(int inputs, char *buff, int len)
+{
+    int nused = 0;
+    if (inputs & TCP_SYN)
+    {
+        nused += snprintf(buff + nused, len - nused, "TCP_SYN ");
+    }
+    if (inputs & TCP_SYN_ACK)
+    {
+        nused += snprintf(buff + nused, len - nused, "TCP_SYN_ACK ");
+    }
+    if (inputs & TCP_FIN)
+    {
+        nused += snprintf(buff + nused, len - nused, "TCP_FIN ");
+    }
+    if (inputs & TCP_RST)
+    {
+        nused += snprintf(buff + nused, len - nused, "TCP_RST ");
+    }
+    if (inputs & TCP_DATA)
+    {
+        nused += snprintf(buff + nused, len - nused, "TCP_DATA ");
+    }
+    if (inputs & UDP_DATA)
+    {
+        nused += snprintf(buff + nused, len - nused, "UDP_DATA ");
+    }
+    if (inputs & TIMEOUT)
+    {
+        nused += snprintf(buff + nused, len - nused, "TIMEOUT ");
+    }
+    if (inputs & LRU_EVICT)
+    {
+        nused += snprintf(buff + nused, len - nused, "LRU_EVICT ");
+    }
+}
+
+void session_transition_init()
+{
+    // SESSION_STATE_INIT    -> SESSION_STATE_OPENING         ( TCP_SYN | TCP_SYN_ACK | UDP_DATA )
+    // SESSION_STATE_INIT    -> SESSION_STATE_INIT            ( NONE )
+
+    fsm[SESSION_STATE_INIT][0].inputs_mask = TCP_SYN | TCP_SYN_ACK | UDP_DATA;
+    fsm[SESSION_STATE_INIT][0].next_state = SESSION_STATE_OPENING;
+
+    fsm[SESSION_STATE_INIT][1].inputs_mask = NONE;
+    fsm[SESSION_STATE_INIT][1].next_state = SESSION_STATE_INIT;
+
+    // SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE          ( TCP_DATA | UDP_DATA )
+    // SESSION_STATE_OPENING -> SESSION_STATE_CLOSING         ( TCP_FIN | TCP_RST | TIMEOUT )
+    // SESSION_STATE_OPENING -> SESSION_STATE_CLOSED          ( LRU_EVICT )
+    // SESSION_STATE_OPENING -> SESSION_STATE_OPENING         ( NONE )
+
+    fsm[SESSION_STATE_OPENING][0].inputs_mask = TCP_DATA | UDP_DATA;
+    fsm[SESSION_STATE_OPENING][0].next_state = SESSION_STATE_ACTIVE;
+
+    fsm[SESSION_STATE_OPENING][1].inputs_mask = TCP_FIN | TCP_RST | TIMEOUT;
+    fsm[SESSION_STATE_OPENING][1].next_state = SESSION_STATE_CLOSING;
+
+    fsm[SESSION_STATE_OPENING][2].inputs_mask = LRU_EVICT;
+    fsm[SESSION_STATE_OPENING][2].next_state = SESSION_STATE_CLOSED;
+
+    fsm[SESSION_STATE_OPENING][3].inputs_mask = NONE;
+    fsm[SESSION_STATE_OPENING][3].next_state = SESSION_STATE_OPENING;
+
+    // SESSION_STATE_ACTIVE  -> SESSION_STATE_CLOSING         ( TCP_FIN | TCP_RST | TIMEOUT )
+    // SESSION_STATE_ACTIVE  -> SESSION_STATE_CLOSED          ( LRU_EVICT )
+    // SESSION_STATE_ACTIVE  -> SESSION_STATE_ACTIVE          ( NONE )
+
+    fsm[SESSION_STATE_ACTIVE][0].inputs_mask = TCP_FIN | TCP_RST | TIMEOUT;
+    fsm[SESSION_STATE_ACTIVE][0].next_state = SESSION_STATE_CLOSING;
+
+    fsm[SESSION_STATE_ACTIVE][1].inputs_mask = LRU_EVICT;
+    fsm[SESSION_STATE_ACTIVE][1].next_state = SESSION_STATE_CLOSED;
+
+    fsm[SESSION_STATE_ACTIVE][2].inputs_mask = NONE;
+    fsm[SESSION_STATE_ACTIVE][2].next_state = SESSION_STATE_ACTIVE;
+
+    // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED          ( TIMEOUT | LRU_EVICT )
+    // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING         ( NONE )
+
+    fsm[SESSION_STATE_CLOSING][0].inputs_mask = TIMEOUT | LRU_EVICT;
+    fsm[SESSION_STATE_CLOSING][0].next_state = SESSION_STATE_CLOSED;
+
+    fsm[SESSION_STATE_CLOSING][1].inputs_mask = NONE;
+    fsm[SESSION_STATE_CLOSING][1].next_state = SESSION_STATE_CLOSING;
+}
+
+enum session_state session_transition_run(enum session_state curr_state, int inputs)
+{
+    struct session_transition *list = fsm[curr_state];
+    for (int i = 0; i < MAX_TRANSITION_PER_STATE; i++)
+    {
+        int mask = list[i].inputs_mask;
+        if (mask & inputs)
+        {
+            return list[i].next_state;
+        }
+        if (mask == NONE)
+        {
+            return list[i].next_state;
+        }
+    }
+
+    assert(0);
+    return curr_state;
+}
+
+void session_transition_log(struct session *sess, enum session_state curr_state, enum session_state next_state, int inputs)
+{
+    if (curr_state == next_state)
+    {
+        return;
+    }
+
+    char buff[128] = {0};
+    char reason[128] = {0};
+    tuple6_to_str(session_get0_key(sess), buff, sizeof(buff));
+    session_inputs_to_str(inputs, reason, sizeof(reason));
+    SESSION_TRANSITION_LOG_DEBUG("%s session %lu %s (%s) %s -> %s",
+                                 session_type_to_str(session_get_type(sess)), session_get_id(sess), buff, reason,
+                                 session_state_to_str(curr_state), session_state_to_str(next_state));
+}