Session Cleanup

CMakeLists.txt

@@ -31,6 +31,8 @@ add_library(worker_lib STATIC src/worker.c)
 add_library(properties_lib STATIC src/properties.c)
 add_library(poll_array_lib STATIC src/data_structures/poll_array.c)
 add_library(marked_fds_lib STATIC src/data_structures/marked_fds.c)
+add_library(session_lib STATIC src/data_structures/session.c)
+add_library(current_session_lib STATIC src/data_structures/current_session.c)
 add_library(buffer_lib STATIC src/data_structures/buffer.c)
 add_library(http_request_lib STATIC src/http/request.c)
 add_library(http_response_lib STATIC src/http/response.c)
@@ -44,7 +46,6 @@ add_library(ssl_utils_lib STATIC src/utils/ssl.c)
 add_library(db_migration_utils_lib STATIC src/utils/db_migration.c)
 add_library(signal_wrapper_lib STATIC src/shutdown/signal2.c)
 add_library(stop_lib STATIC src/shutdown/stop.c)
-add_library(session_lib STATIC src/data_structures/session.c)
 
 
 # Handlers libraries
@@ -63,18 +64,18 @@ add_library(simulator_http_lib STATIC test/simulator/http_cases.c)
 
 
 add_executable(main src/main.c ${HEADER_FILES})
-target_link_libraries(main PRIVATE listener_lib worker_lib builder_lib loader_lib parser_lib sender_lib http_request_lib http_response_lib socket_lib signal_wrapper_lib poll_array_lib db_migration_utils_lib file_utils_lib compression_utils_lib regex_utils_lib hash_utils_lib ssl_utils_lib assert_utils_lib logger_utils_lib session_lib marked_fds_lib stop_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB SQLite::SQLite3)
+target_link_libraries(main PRIVATE listener_lib worker_lib builder_lib loader_lib parser_lib sender_lib http_request_lib http_response_lib socket_lib signal_wrapper_lib poll_array_lib db_migration_utils_lib file_utils_lib compression_utils_lib regex_utils_lib hash_utils_lib ssl_utils_lib session_lib assert_utils_lib logger_utils_lib current_session_lib marked_fds_lib stop_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB SQLite::SQLite3)
 enable_compile_options(main)
 #enable_address_sanitizer(main)
 
 add_executable(client test/simulator/client.c)
-target_link_libraries(client PRIVATE simulator_cases_lib simulator_http_lib simulator_connection_lib socket_lib compression_utils_lib hash_utils_lib assert_utils_lib logger_utils_lib session_lib stop_lib marked_fds_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB CURL::libcurl SQLite::SQLite3)
+target_link_libraries(client PRIVATE simulator_cases_lib simulator_http_lib simulator_connection_lib socket_lib compression_utils_lib hash_utils_lib session_lib assert_utils_lib logger_utils_lib stop_lib current_session_lib marked_fds_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB CURL::libcurl SQLite::SQLite3)
 enable_compile_options(client)
 # enable_address_sanitizer(client)
 
 
 add_executable(unit_test test/unit_tests/all_tests.c)
-target_link_libraries(unit_test PRIVATE http_request_lib http_response_lib file_utils_lib regex_utils_lib poll_array_lib compression_utils_lib hash_utils_lib properties_lib assert_utils_lib logger_utils_lib session_lib stop_lib marked_fds_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB)
+target_link_libraries(unit_test PRIVATE http_request_lib http_response_lib file_utils_lib regex_utils_lib poll_array_lib compression_utils_lib hash_utils_lib properties_lib session_lib assert_utils_lib logger_utils_lib stop_lib current_session_lib marked_fds_lib properties_lib static_lib buffer_lib OpenSSL::SSL OpenSSL::Crypto Threads::Threads ZLIB::ZLIB)
 enable_compile_options(unit_test)
 #enable_address_sanitizer(unit_test)
 # Add custom target to copy the static folder

README.md

@@ -122,11 +122,9 @@ enable_https = 0 (binary value for enabling HTTPS)
 * Performance optimization (spacial locality?)
 * A thread/path that listens to console/http input and can send commands to the server (e.g. reload config, shutdown, etc.)
 * Basic Auth
-* One thread per request (Apache)
-* One list per state
 * ENSURE_CAPACITY use assert for checking for memory issues...
 * Request/response logger
-* Move session arrays to one struct
+* HTTP/JSON parser
 
 ## Try to remember
 * Clean up includes

src/data_structures/current_session.c

@@ -0,0 +1,7 @@
+#include "current_session.h"
+
+static __thread int thread_session_id = -1;
+
+void put_current_session(int session_id) { thread_session_id = session_id; }
+int get_current_session() { return thread_session_id; }
+void clear_current_session() { thread_session_id = -1; }

src/data_structures/current_session.h

@@ -0,0 +1,8 @@
+#ifndef CURRENT_SESSION_H
+#define CURRENT_SESSION_H
+
+void put_current_session(int session_id);
+int get_current_session();
+void clear_current_session();
+
+#endif // CURRENT_SESSION_H

src/data_structures/map_impl.c

@@ -0,0 +1,123 @@
+#include "session_by_thread_map.h"
+#include <pthread.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TABLE_MAX_LOAD 0.75
+
+typedef struct {
+  unsigned long thread_id;
+  int session_id;
+} entry_t;
+
+typedef struct {
+  unsigned int count;
+  unsigned int capacity;
+  entry_t *entries;
+} table_t;
+
+static table_t table = {
+    .count = 0,
+    .capacity = 0,
+    .entries = NULL,
+};
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static entry_t *find_entry(entry_t *entries, unsigned long thread_id);
+static int grow_capacity();
+
+void destroy_session_by_thread_map() {
+  pthread_mutex_lock(&mutex);
+  if (table.entries != NULL) {
+    free(table.entries);
+    table.entries = NULL;
+  }
+  table.capacity = 0;
+  table.count = 0;
+  pthread_mutex_unlock(&mutex);
+}
+
+int put_session_id_by_thread(int session_id) {
+  pthread_mutex_lock(&mutex);
+
+  if (table.count + 1 > table.capacity * TABLE_MAX_LOAD) {
+    int result = grow_capacity();
+    if (result < 0) {
+      pthread_mutex_unlock(&mutex);
+      return result;
+    }
+  }
+  unsigned long thread_id = pthread_self();
+  entry_t *entry = find_entry(table.entries, thread_id);
+  bool is_new_entry = entry->session_id == -1;
+  if (session_id == -1)
+    table.count -= 1;
+  else if (is_new_entry)
+    table.count += 1;
+
+  entry->session_id = session_id;
+  entry->thread_id = thread_id;
+  pthread_mutex_unlock(&mutex);
+  return 1;
+}
+
+int get_session_id_by_thread() {
+  pthread_mutex_lock(&mutex);
+  int result = -1;
+
+  if (table.count > 0) {
+    result = find_entry(table.entries, pthread_self())->session_id;
+  }
+
+  pthread_mutex_unlock(&mutex);
+  return result;
+}
+
+static entry_t *find_entry(entry_t *entries, unsigned long thread_id) {
+  unsigned int index = thread_id % table.capacity;
+
+  while (1) {
+    entry_t *entry = &table.entries[index];
+    if (entry->thread_id == thread_id || entry->session_id == -1) {
+      return entry;
+    }
+
+    index = (index + 1) % table.capacity;
+  }
+}
+
+static int grow_capacity() {
+  unsigned int new_capacity;
+  if (table.capacity == 0) {
+    new_capacity = 16;
+  } else {
+    new_capacity *= 2;
+  }
+
+  entry_t *new_entries = malloc(sizeof(entry_t) * new_capacity);
+  if (new_entries == NULL) {
+    return -1;
+  }
+
+  for (int i = 0; i < new_capacity; i++) {
+    new_entries[i].session_id = -1;
+    new_entries[i].thread_id = -1;
+  }
+
+  for (int i = 0; i < table.capacity; i++) {
+    entry_t *entry = &table.entries[i];
+    if (entry->session_id == -1)
+      continue;
+
+    entry_t *dest = find_entry(new_entries, entry->thread_id);
+    dest->thread_id = entry->thread_id;
+    dest->session_id = entry->session_id;
+  }
+
+  free(table.entries);
+  table.entries = new_entries;
+  table.capacity = new_capacity;
+  return table.capacity;
+}