Add session table & session

src/session/session.cpp

@@ -0,0 +1,306 @@
+#include <assert.h>
+
+#include "session_private.h"
+
+#define EX_KEY_MAX_LEN 64
+
+struct ex_schema
+{
+    char key[EX_KEY_MAX_LEN];
+    session_ex_free_cb *free_cb;
+    void *args;
+};
+
+struct ex_manager
+{
+    struct ex_schema schemas[EX_DATA_MAX_COUNT];
+    uint8_t count;
+};
+
+static struct ex_manager g_ex_manager = {0};
+
+/******************************************************************************
+ * ev queue
+ ******************************************************************************/
+
+static void event_queue_init(struct event_queue *queue)
+{
+    queue->head_idx = 0;
+    queue->tail_idx = 0;
+}
+
+static bool event_queue_is_empty(struct event_queue *queue)
+{
+    return queue->head_idx == queue->tail_idx;
+}
+
+static bool event_queue_is_full(struct event_queue *queue)
+{
+    return (queue->tail_idx + 1) % SESSION_EVENT_QUEUE_SIZE == queue->head_idx;
+}
+
+static bool event_queue_push(struct event_queue *queue, uint32_t event)
+{
+    if (event_queue_is_full(queue))
+    {
+        return false;
+    }
+
+    queue->events[queue->tail_idx] = event;
+    queue->tail_idx = (queue->tail_idx + 1) % SESSION_EVENT_QUEUE_SIZE;
+
+    return true;
+}
+
+static bool event_queue_pop(struct event_queue *queue, uint32_t *event)
+{
+    if (event_queue_is_empty(queue))
+    {
+        return false;
+    }
+
+    *event = queue->events[queue->head_idx];
+    queue->head_idx = (queue->head_idx + 1) % SESSION_EVENT_QUEUE_SIZE;
+
+    return true;
+}
+
+/******************************************************************************
+ * session
+ ******************************************************************************/
+
+void session_init(struct session *sess)
+{
+    memset(sess, 0, sizeof(struct session));
+    event_queue_init(&sess->events);
+}
+
+// session id
+void session_set_id(struct session *sess, uint64_t id)
+{
+    sess->id = id;
+}
+
+uint64_t session_get_id(struct session *sess)
+{
+    return sess->id;
+}
+
+// session address
+void session_set_address(struct session *sess, struct session_address *addr)
+{
+    memcpy(&sess->addr, addr, sizeof(struct session_address));
+}
+
+struct session_address *session_get0_address(struct session *sess)
+{
+    return &sess->addr;
+}
+
+// session state
+void session_set_state(struct session *sess, enum session_state state)
+{
+    sess->state = state;
+}
+
+enum session_state session_get_state(struct session *sess)
+{
+    return sess->state;
+}
+
+// session type
+void session_set_type(struct session *sess, enum session_type type)
+{
+    sess->type = type;
+}
+
+enum session_type session_get_type(struct session *sess)
+{
+    return sess->type;
+}
+
+// session metrics
+void session_inc_c2s_metrics(struct session *sess, uint64_t packets, uint64_t bytes)
+{
+    sess->c2s_bytes += bytes;
+    sess->c2s_packets += packets;
+}
+
+void session_inc_s2c_metrics(struct session *sess, uint64_t packets, uint64_t bytes)
+{
+    sess->s2c_bytes += bytes;
+    sess->s2c_packets += packets;
+}
+
+uint64_t session_get_c2s_bytes(struct session *sess)
+{
+    return sess->c2s_bytes;
+}
+
+uint64_t session_get_s2c_bytes(struct session *sess)
+{
+    return sess->s2c_bytes;
+}
+
+uint64_t session_get_c2s_packets(struct session *sess)
+{
+    return sess->c2s_packets;
+}
+
+uint64_t session_get_s2c_packets(struct session *sess)
+{
+    return sess->s2c_packets;
+}
+
+// session metadata
+void session_set_c2s_1st_md(struct session *sess, struct metadata *md)
+{
+    memcpy(&sess->c2s_1st_md, md, sizeof(struct metadata));
+}
+
+void session_set_s2c_1st_md(struct session *sess, struct metadata *md)
+{
+    memcpy(&sess->s2c_1st_md, md, sizeof(struct metadata));
+}
+
+struct metadata *session_get0_c2s_1st_md(struct session *sess)
+{
+    return &sess->c2s_1st_md;
+}
+
+struct metadata *session_get0_s2c_1st_md(struct session *sess)
+{
+    return &sess->s2c_1st_md;
+}
+
+// session timestamp
+void session_set_create_time(struct session *sess, uint64_t timestamp)
+{
+    sess->create_time = timestamp;
+}
+
+void session_set_last_time(struct session *sess, uint64_t timestamp)
+{
+    sess->last_time = timestamp;
+}
+
+void session_set_expire_time(struct session *sess, uint64_t timestamp)
+{
+    sess->expire_time = timestamp;
+}
+
+uint64_t session_get_create_time(struct session *sess)
+{
+    return sess->create_time;
+}
+
+uint64_t session_get_last_time(struct session *sess)
+{
+    return sess->last_time;
+}
+
+uint64_t session_get_expire_time(struct session *sess)
+{
+    return sess->expire_time;
+}
+
+// session event
+bool session_push_event(struct session *sess, uint32_t event)
+{
+    return event_queue_push(&sess->events, event);
+}
+
+bool session_pop_event(struct session *sess, uint32_t *event)
+{
+    return event_queue_pop(&sess->events, event);
+}
+
+/******************************************************************************
+ * session ex data
+ ******************************************************************************/
+
+/*
+ * the exdata prodoced by user, and comsumed by same user.
+ * so, the exdata is not shared by different user.
+ * otherwise, the exdata need dup by refer count, and free by refer count.
+ *
+ * if key exist, not allow update, return original index.
+ */
+uint8_t session_get_ex_new_index(const char *key, session_ex_free_cb *free_cb, void *args)
+{
+    if (g_ex_manager.count >= EX_DATA_MAX_COUNT)
+    {
+        abort();
+        return EX_DATA_MAX_COUNT;
+    }
+
+    for (uint8_t i = 0; i < g_ex_manager.count; i++)
+    {
+        if (strcmp(g_ex_manager.schemas[i].key, key) == 0)
+        {
+            return i;
+        }
+    }
+
+    uint8_t idx = g_ex_manager.count;
+    g_ex_manager.count++;
+
+    struct ex_schema *schema = &g_ex_manager.schemas[idx];
+    strncpy(schema->key, key, EX_KEY_MAX_LEN);
+    schema->free_cb = free_cb;
+    schema->args = args;
+
+    return idx;
+}
+
+/*
+ * Support update ex_data.
+ *
+ * if key exist: run free_cb free old value, then set new value.
+ *     if not run free_cb, old value will be memory leak.
+ *     if not allow update, new value will be memory leak.
+ * if key not exist: set new value.
+ */
+void session_set_ex_data(struct session *sess, uint8_t idx, void *val)
+{
+    if (idx >= g_ex_manager.count)
+    {
+        assert(0);
+        return;
+    }
+
+    session_free_ex_data(sess, idx);
+    sess->ex_data[idx] = val;
+}
+
+void *session_get0_ex_data(struct session *sess, uint8_t idx)
+{
+    if (idx >= g_ex_manager.count)
+    {
+        assert(0);
+        return NULL;
+    }
+
+    return sess->ex_data[idx];
+}
+
+/*
+ * after set ex_data, the owner of ex_data is session, so user should not free it directly.
+ * if user want to free ex_data, should use session_free_ex_data.
+ */
+void session_free_ex_data(struct session *sess, uint8_t idx)
+{
+    if (idx >= g_ex_manager.count)
+    {
+        assert(0);
+        return;
+    }
+
+    struct ex_schema *schema = &g_ex_manager.schemas[idx];
+    if (schema->free_cb != NULL && sess->ex_data[idx] != NULL)
+    {
+        schema->free_cb(sess, idx, sess->ex_data[idx], schema->args);
+    }
+
+    sess->ex_data[idx] = NULL;
+}