From: jxnshi <jxnshi@proton.me>
Date: Fri, 21 Feb 2025 13:35:05 +0000 (+0100)
Subject: Update
X-Git-Url: https://jxnshi.xyz/repos?a=commitdiff_plain;h=1a152e5f4b5a863f9e08c750cba771e9d860f0f5;p=mesange.git

Update
---

diff --git a/client-cli/client-cli b/client-cli/client-cli
new file mode 100755
index 0000000..2ef8885
Binary files /dev/null and b/client-cli/client-cli differ
diff --git a/client-cli/command.odin b/client-cli/command.odin
index b21a881..48cd8ad 100644
--- a/client-cli/command.odin
+++ b/client-cli/command.odin
@@ -143,8 +143,10 @@ handle_command :: proc(app: ^App, command: string) -> Maybe(Handle_Command_Error
             }
 
             callback :: proc(app: ^App, response: common.Server_Response) {
+                response := response.(string)
+
                 if response != "" {
-                    // app_set_info_bar(app, "Failed to subscribe to room.")
+                    app_set_info_bar(app, "Failed to subscribe to room.")
                     return
                 }
             }
diff --git a/client-cli/host.odin b/client-cli/host.odin
index 02fc710..1adc015 100644
--- a/client-cli/host.odin
+++ b/client-cli/host.odin
@@ -57,8 +57,8 @@ request_host :: proc(
     _ = net.send_tcp(app.host.?, request_bytes) or_return
 
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         app.requests_callbacks[id] = callback
     }
diff --git a/client-cli/main.odin b/client-cli/main.odin
index b33b447..61c8a9b 100644
--- a/client-cli/main.odin
+++ b/client-cli/main.odin
@@ -1,5 +1,4 @@
 package main
-
 import "base:runtime"
 
 import "core:encoding/json"
@@ -36,8 +35,8 @@ json_marshal_options := json.Marshal_Options{
 }
 
 App :: struct {
-    mutex: sync.Mutex,
-    state_mutex: sync.Mutex,
+    ui_mutex: sync.Mutex,
+    data_mutex: sync.Mutex,
 
     running: bool,
 
@@ -126,8 +125,8 @@ app_init :: proc(storage_path: string) -> App {
 }
 
 app_deinit :: proc(app: ^App) {
-    sync.mutex_lock(&app.mutex)
-    defer sync.mutex_unlock(&app.mutex)
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
 
     delete(app.requests_callbacks)
 
@@ -168,12 +167,18 @@ app_deinit :: proc(app: ^App) {
 }
 
 app_update_room_list_window :: proc(app: ^App) {
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
+
     room_list_window, ok := app.room_list_window.?
 
     if !ok {
         return
     }
 
+    sync.mutex_lock(&app.ui_mutex)
+    defer sync.mutex_unlock(&app.ui_mutex)
+
     nc.wclear(room_list_window)
 
     c_room_name_buffer: [ROOM_NAME_MAX_SIZE + 1]u8
@@ -216,6 +221,9 @@ app_update_room_list_window :: proc(app: ^App) {
 }
 
 app_update_room_window :: proc(app: ^App) {
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
+
     room_window, ok := app.room_window.?
 
     if !ok {
@@ -236,11 +244,13 @@ app_update_room_window :: proc(app: ^App) {
 }
 
 app_set_state :: proc(app: ^App, state: State) {
-    sync.mutex_lock(&app.state_mutex)
-    defer sync.mutex_unlock(&app.state_mutex)
+    {
+        sync.mutex_lock(&app.ui_mutex)
+        defer sync.mutex_unlock(&app.ui_mutex)
 
-    nc.clear()
-    nc.refresh()
+        nc.clear()
+        nc.refresh()
+    }
 
     app_clear_box_message(app)
     app_update_info_bar(app)
@@ -250,29 +260,34 @@ app_set_state :: proc(app: ^App, state: State) {
 
     app.state = state
 
-    if app.state == .Room_List || app.state == .Room {
-        if app.room_list_window == nil {
-            app.room_list_window = nc.newwin(screen_height - 2, 34, 0, 0)
-        }
+    {
+        sync.mutex_lock(&app.ui_mutex)
+        defer sync.mutex_unlock(&app.ui_mutex)
 
-        if app.room_window == nil {
-            app.room_window = nc.newwin(screen_height - 2, screen_width - 34, 0, 34)
-        }
-    } else {
-        if host, ok := app.host.?; ok {
-            net.close(host)
-        }
+        if app.state == .Room_List || app.state == .Room {
+            if app.room_list_window == nil {
+                app.room_list_window = nc.newwin(screen_height - 2, 34, 0, 0)
+            }
 
-        if room_list_window, ok := app.room_list_window.?; ok {
-            nc.wclear(room_list_window)
-            nc.wrefresh(room_list_window)
-            nc.delwin(room_list_window)
-        }
+            if app.room_window == nil {
+                app.room_window = nc.newwin(screen_height - 2, screen_width - 34, 0, 34)
+            }
+        } else {
+            if host, ok := app.host.?; ok {
+                net.close(host)
+            }
 
-        if room_window, ok := app.room_window.?; ok {
-            nc.wclear(room_window)
-            nc.wrefresh(room_window)
-            nc.delwin(room_window)
+            if room_list_window, ok := app.room_list_window.?; ok {
+                nc.wclear(room_list_window)
+                nc.wrefresh(room_list_window)
+                nc.delwin(room_list_window)
+            }
+
+            if room_window, ok := app.room_window.?; ok {
+                nc.wclear(room_window)
+                nc.wrefresh(room_window)
+                nc.delwin(room_window)
+            }
         }
     }
 
@@ -295,17 +310,24 @@ app_set_info_bar :: proc(app: ^App, format: string, args: ..any) {
         return
     }
 
-    sync.mutex_lock(&app.mutex)
-    defer sync.mutex_unlock(&app.mutex)
+    {
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
-    if app.info_bar_content != "" {
-        delete(app.info_bar_content)
+        if app.info_bar_content != "" {
+
+            delete(app.info_bar_content)
+        }
     }
 
     defer app_update_info_bar(app)
 
     if format == "" {
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
+
         app.info_bar_content = ""
+
         return
     }
 
@@ -314,6 +336,9 @@ app_set_info_bar :: proc(app: ^App, format: string, args: ..any) {
 
     fmt.sbprintf(&info_bar_content_builder, format, ..args)
 
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
+
     app.info_bar_content = strings.to_string(info_bar_content_builder)
 }
 
@@ -341,21 +366,26 @@ app_set_box_message :: proc(app: ^App, lines: []string) {
 
     color := nc.COLOR_PAIR(2)
 
-    nc.wattron(box_message, color)
+    {
+        sync.mutex_lock(&app.ui_mutex)
+        defer sync.mutex_unlock(&app.ui_mutex)
 
-    for line, i in lines {
-        c_line := strings.clone_to_cstring(line, context.temp_allocator)
-        nc.mvwprintw(box_message, i32(i + 1), 2, c_line)
-    }
+        nc.wattron(box_message, color)
 
-    nc.box(box_message, 0, 0)
-    nc.wattroff(box_message, color)
+        for line, i in lines {
+            c_line := strings.clone_to_cstring(line, context.temp_allocator)
+            nc.mvwprintw(box_message, i32(i + 1), 2, c_line)
+        }
 
-    nc.wrefresh(box_message)
+        nc.box(box_message, 0, 0)
+        nc.wattroff(box_message, color)
+
+        nc.wrefresh(box_message)
+    }
 
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         if box_message, ok := app.box_message.?; ok {
             nc.delwin(box_message)
@@ -366,6 +396,9 @@ app_set_box_message :: proc(app: ^App, lines: []string) {
 }
 
 app_update_info_bar :: proc(app: ^App) {
+    sync.mutex_lock(&app.ui_mutex)
+    defer sync.mutex_unlock(&app.ui_mutex)
+
     height, width := nc.getmaxyx(app.info_bar)
     color := nc.COLOR_PAIR(1)
 
@@ -384,7 +417,13 @@ app_update_info_bar :: proc(app: ^App) {
 }
 
 app_clear_box_message :: proc(app: ^App) {
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
+
     if box_message, ok := app.box_message.?; ok {
+        sync.mutex_lock(&app.ui_mutex)
+        defer sync.mutex_unlock(&app.ui_mutex)
+
         nc.wclear(box_message)
         nc.wrefresh(box_message)
         nc.delwin(box_message)
@@ -439,21 +478,28 @@ app_get_input :: proc(
     allow_empty := false,
     allocator := context.allocator,
 ) -> string {
-    sync.mutex_lock(&app.state_mutex)
-    defer sync.mutex_unlock(&app.state_mutex)
-
     context.allocator = allocator
 
     for {
-        nc.wclear(app.input_window)
-        nc.wrefresh(app.input_window)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
+
+            nc.wclear(app.input_window)
+            nc.wrefresh(app.input_window)
+        }
 
         buffer: [256]u8
         buffer_len, cursor_pos: int
 
         screen_height, screen_width := nc.getmaxyx(app.screen)
 
-        nc.curs_set(1)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
+            
+            nc.curs_set(1)
+        }
 
         input_loop: for {
             char, ok := handle_getch(app, &buffer_len, &cursor_pos).?
@@ -485,19 +531,29 @@ app_get_input :: proc(
             buffer[buffer_len] = 0
             output := string(buffer[:buffer_len + 1])
 
-            nc.wclear(app.input_window)
+            {
+                sync.mutex_lock(&app.ui_mutex)
+                defer sync.mutex_unlock(&app.ui_mutex)
 
-            if !hidden || (buffer_len != 0 && buffer[0] == ':') {
-                nc.mvwprintw(app.input_window, 0, 0, strings.unsafe_string_to_cstring(output))
-                nc.wmove(app.input_window, 0, i32(cursor_pos))
-            }
+                nc.wclear(app.input_window)
 
-            nc.wrefresh(app.input_window)
+                if !hidden || (buffer_len != 0 && buffer[0] == ':') {
+                    nc.mvwprintw(app.input_window, 0, 0, strings.unsafe_string_to_cstring(output))
+                    nc.wmove(app.input_window, 0, i32(cursor_pos))
+                }
+
+                nc.wrefresh(app.input_window)
+            }
         }
 
-        nc.curs_set(0)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
 
-        nc.wclear(app.input_window)
+            nc.curs_set(0)
+
+            nc.wclear(app.input_window)
+        }
 
         c_input := cstring(raw_data(buffer[:]))
 
@@ -529,21 +585,28 @@ app_get_input_or_event :: proc(
     only_command := false,
     allocator := context.allocator,
 ) -> Input_Or_Event {
-    sync.mutex_lock(&app.state_mutex)
-    defer sync.mutex_unlock(&app.state_mutex)
-
     context.allocator = allocator
 
     for {
-        nc.wclear(app.input_window)
-        nc.wrefresh(app.input_window)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
+
+            nc.wclear(app.input_window)
+            nc.wrefresh(app.input_window)
+        }
 
         buffer: [256]u8
         buffer_len, cursor_pos: int
 
         screen_height, screen_width := nc.getmaxyx(app.screen)
 
-        nc.curs_set(1)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
+
+            nc.curs_set(1)
+        }
 
         input_loop: for {
             char, ok := handle_getch(app, &buffer_len, &cursor_pos).?
@@ -596,17 +659,27 @@ app_get_input_or_event :: proc(
 
             output := string(buffer[:buffer_len + 1])
 
-            nc.wclear(app.input_window)
+            {
+                sync.mutex_lock(&app.ui_mutex)
+                defer sync.mutex_unlock(&app.ui_mutex)
 
-            nc.mvwprintw(app.input_window, 0, 0, strings.unsafe_string_to_cstring(output))
-            nc.wmove(app.input_window, 0, i32(cursor_pos))
+                nc.wclear(app.input_window)
 
-            nc.wrefresh(app.input_window)
+                nc.mvwprintw(app.input_window, 0, 0, strings.unsafe_string_to_cstring(output))
+                nc.wmove(app.input_window, 0, i32(cursor_pos))
+
+                nc.wrefresh(app.input_window)
+            }
         }
 
-        nc.curs_set(0)
+        {
+            sync.mutex_lock(&app.ui_mutex)
+            defer sync.mutex_unlock(&app.ui_mutex)
+
+            nc.curs_set(0)
 
-        nc.wclear(app.input_window)
+            nc.wclear(app.input_window)
+        }
 
         c_input := cstring(raw_data(buffer[:]))
 
@@ -631,6 +704,9 @@ app_reset_seed_phrase :: proc(app: ^App) {
     entropy_hash: [sha3.DIGEST_SIZE_256]u8
     sha3.final(&sha_context, entropy_hash[:])
 
+    sync.mutex_lock(&app.data_mutex)
+    defer sync.mutex_unlock(&app.data_mutex)
+
     app.seed_phrase_checksum = entropy_hash[0] & 0b1111
 }
 
@@ -649,18 +725,29 @@ app_room_key_exists :: proc(app: ^App, key: [ROOM_KEY_SIZE]u8) -> bool {
 app_add_room :: proc(app: ^App, room: Room) {
     room := room
 
-    append(&app.profile.rooms, room)
+    {
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
+
+        append(&app.profile.rooms, room)
+        profile_update(app.profile, app)
+    }
 
-    profile_update(app.profile, app)
     app_update_room_list_window(app)
 }
 
 app_remove_room :: proc(app: ^App, index: int) {
-    ordered_remove(&app.profile.rooms, index)
-    profile_update(app.profile, app)
+    {
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
+
+        ordered_remove(&app.profile.rooms, index)
+
+        if app.selected_room != 0 && app.selected_room >= len(app.profile.rooms) {
+            app.selected_room = len(app.profile.rooms) - 1
+        }
 
-    if app.selected_room >= len(app.profile.rooms) {
-        app.selected_room = len(app.profile.rooms) - 1
+        profile_update(app.profile, app)
     }
 
     app_update_room_list_window(app)
@@ -702,8 +789,8 @@ handle_host :: proc(app: ^App) {
         state: State
 
         {
-            sync.mutex_lock(&app.mutex)
-            defer sync.mutex_unlock(&app.mutex)
+            sync.mutex_lock(&app.data_mutex)
+            defer sync.mutex_unlock(&app.data_mutex)
 
             state = app.state
         }
@@ -735,8 +822,8 @@ handle_host :: proc(app: ^App) {
                 callback: Request_Callback
 
                 {
-                    sync.mutex_lock(&app.mutex)
-                    defer sync.mutex_unlock(&app.mutex)
+                    sync.mutex_lock(&app.data_mutex)
+                    defer sync.mutex_unlock(&app.data_mutex)
 
                     callback = app.requests_callbacks[message_id]
                     delete_key(&app.requests_callbacks, message_id)
@@ -754,7 +841,7 @@ main :: proc() {
     home_path := os.get_env("HOME")
     defer delete(home_path)
 
-    storage_path := fpath.join({ home_path, "mesange" })
+    storage_path := fpath.join({ home_path, "mesange", "client" })
     defer delete(storage_path)
 
     // Setup logger.
@@ -843,8 +930,8 @@ main :: proc() {
             free_all(context.temp_allocator)
         }
 
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         if !app.running {
             break
diff --git a/client-cli/state.odin b/client-cli/state.odin
index 1616d5c..5234672 100644
--- a/client-cli/state.odin
+++ b/client-cli/state.odin
@@ -51,8 +51,8 @@ state_load_config :: proc(app: ^App) {
     }
 
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         app.config = config
     }
@@ -118,8 +118,8 @@ state_load_profile :: proc(app: ^App) {
     }
 
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         app.profile = profile
     }
@@ -175,8 +175,8 @@ state_ask_profile :: proc(app: ^App) {
     }
 
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         app.config.selected_profile = input
     }
@@ -322,8 +322,8 @@ state_ask_profile_hosts :: proc(app: ^App) {
     }
     
     {
-        sync.mutex_lock(&app.mutex)
-        defer sync.mutex_unlock(&app.mutex)
+        sync.mutex_lock(&app.data_mutex)
+        defer sync.mutex_unlock(&app.data_mutex)
 
         app.profile.hosts = input
     }
diff --git a/server/main.odin b/server/main.odin
index 0e65d17..9ab2064 100644
--- a/server/main.odin
+++ b/server/main.odin
@@ -15,8 +15,10 @@ import "core:thread"
 import "../common"
 
 Handle_Client_Data :: struct {
+    data_mutex: ^sync.Mutex,
+    db_mutex: ^sync.Mutex,
+
     clients_sockets: ^map[net.Endpoint]net.TCP_Socket,
-    mutex: ^sync.Mutex,
 
     client_socket: net.TCP_Socket,
     client_endpoint: net.Endpoint,
@@ -30,8 +32,8 @@ handle_client :: proc(data: Handle_Client_Data) {
     defer {
         log.infof("Client %v disconnected.", client_endpoint_string)
 
-        sync.mutex_lock(mutex)
-        defer sync.mutex_unlock(mutex)
+        sync.mutex_lock(data_mutex)
+        defer sync.mutex_unlock(data_mutex)
 
         delete_key(clients_sockets, client_endpoint)
     }
diff --git a/server/server b/server/server
index c779319..b8df374 100755
Binary files a/server/server and b/server/server differ