Refactor the JSON-RPC connection

CHANGELOG.md

@@ -8,6 +8,23 @@ and this project adheres to
 
 ## [Unreleased]
 
+### Changed
+
+- The name of the grisp_connect configuration key to control the timeout of
+individual JSON-RPC requests changed from ws_requests_timeout to
+ws_request_timeout.
+- Le default log filter changed to trying to filter out only some messages to
+filtering out all progress messages, as it wasn't working reliably.
+- JSON-RPC logic was extracted into the jarl library.
+- Jarl parses the methods into a list of atom or binaries to pave the
+road for namespaces. foo.bar.Buz is parsed into [foo, bar, <<"Buz">>] (if foo
+and bar are already existing atoms, but 'Buz' is not).
+
+## Fixed
+
+- The client is now waiting 1 second before trying to reconnect when it gets
+disconnected from the server.
+
 ## [1.1.0] - 2024-10-12
 
 ### Added

config/dev.config

@@ -10,18 +10,16 @@
     ]},
 
     {kernel, [
-        {logger_level, info},
+        {logger_level, debug},
         {logger, [
             {handler, default, logger_std_h, #{
                 config => #{type => standard_io},
+                filter_default => log,
                 filters => [
-                    % Filter out supervisor progress reports so
-                    % TLS certificates are not swamping the console...
-                    {filter_out_progress, {
-                        fun grisp_connect_logger_bin:filter_out/2,
-                        {supervisor, report_progress}}}
+                    {disable_progress, {fun logger_filters:progress/2, stop}}
                 ]
             }}
         ]}
     ]}
+
 ].

config/local.config

@@ -26,5 +26,16 @@
         {port, 8443}
     ]},
 
-    {kernel, [{logger_level, debug}]}
+    {kernel, [
+        {logger_level, debug},
+        {logger, [
+            {handler, default, logger_std_h, #{
+                config => #{type => standard_io},
+                filter_default => log,
+                filters => [
+                    {disable_progress, {fun logger_filters:progress/2, stop}}
+                ]
+            }}
+        ]}
+    ]}
 ].

config/test.config

@@ -14,5 +14,18 @@
     {grisp_connect, [
         {domain, localhost},
         {port, 3030}
+    ]},
+
+    {kernel, [
+        {logger_level, debug},
+        {logger, [
+            {handler, default, logger_std_h, #{
+                config => #{type => standard_io},
+                filter_default => log,
+                filters => [
+                    {disable_progress, {fun logger_filters:progress/2, stop}}
+                ]
+            }}
+        ]}
     ]}
 ].

docs/grisp_connect_architecture.md

@@ -0,0 +1,69 @@
+# Architecture
+
+```mermaid
+graph TD
+    RootSup[VM Root Supervisor]
+
+    subgraph GrispConnectApp[Grisp Connect Application]
+        GrispConnectRootSup[Root Supervisor<br>grisp_connect_sup]
+        GrispConnectLogServer[Log Server<br>grisp_connect_log_server]
+        GrispConnectClient[Client<br>grisp_connect_client]
+
+        GrispConnectRootSup --Supervise--> GrispConnectLogServer
+        GrispConnectRootSup --Supervise--> GrispConnectClient
+        GrispConnectClient --Spawn and Monitor--> JarlConnection
+    end
+
+    subgraph JarlApp[Jarl Application]
+        JarlConnection[JSON-RPC Connection<br>jarl_connection]
+        JarlJsonRpc[JSON-RPC Codec<br>jarl_jsonrpc]
+
+        JarlConnection --Use--> JarlJsonRpc
+    end
+
+    subgraph GunApp[Gun Application]
+        GunRootSup[Gun Root Supervisor<br>gun_sup]
+        GunConnsSup[Gun Connection Supervisor<br>gun_conns_sup]
+        Gun[Gun Connection<br>gun]
+        Gun[Gun HTTP Handler<br>gun_http]
+
+        GunRootSup --Supervise--> GunConnsSup
+        GunConnsSup --Supervise--> Gun
+    end
+
+    RootSup --Supervise--> GrispConnectRootSup
+    RootSup --Supervise--> GunRootSup
+    JarlConnection -.Interact.-> Gun
+```
+
+
+## Client
+
+The client process is the main state machine. Its responsabilities are:
+
+ - Trigger connection/reconnection to the backend.
+ - Expose high-level protocol API to the application.
+ - Implement generic API endpoints.
+
+See the [client documentation](grisp_connect_client.md).
+
+
+## Connection
+
+grisp_connect use the jarl library to handle the JSON-RPC connection.
+
+It is not supervised, the process starting it must monitor it.
+
+It provides a high-level API to a JSON-RPC connection:
+
+ - Perform synchronous requests
+ - Start asynchronous requests
+ - Reply to a request
+ - Send and error result for a request
+ - Send asynchronous notifications
+ - Send generic errors
+
+When performing an asynchronous request, the caller can give an opaque context
+term, that will given back when receiving a response or an error for this
+request, allowing the caller to handle the asynchronous operation without having
+to store information locally.

rebar.config

@@ -1,8 +1,8 @@
 {erl_opts, [debug_info]}.
 {deps, [
-  {grisp, "~> 2.7"},
-  {gun, "2.1.0"},
   jsx,
+  {jarl, {git, "https://github.com/grisp/jarl.git"}},
+  {grisp, "~> 2.7"},
   {grisp_cryptoauth, "~> 2.4"},
   {certifi, "2.13.0"}
 ]}.

src/grisp_connect.app.src

@@ -7,10 +7,10 @@
         kernel,
         inets,
         stdlib,
+        jsx,
+        jarl,
         grisp,
         grisp_cryptoauth,
-        gun,
-        jsx,
         certifi
     ]},
     {optional_applications, [
@@ -21,26 +21,24 @@
         {port, 443},
         {connect, true}, % keeps a constant connection with grisp.io
         {ntp, false}, % if set to true, starts the NTP client
-        {ws_requests_timeout, 5_000},
+        {ws_transport, tls},
+        {ws_path, "/grisp-connect/ws"},
+        {ws_request_timeout, 5_000},
         {ws_ping_timeout, 60_000},
         {logs_interval, 2_000},
         {logs_batch_size, 100},
         {logger, [
-          % Enable our own default handler,
-          % which will receive all events from boot
-          {handler,
-           grisp_connect_log_handler,
-           grisp_connect_logger_bin,
-           #{formatter => {grisp_connect_logger_bin, #{}},
-             % Filter out supervisor progress reports to prevent the ones
-             % from tls_dyn_connection_sup that logs all the certificates
-             % to crash the connection...
-             filters => [
-                {filter_out_progress,
-                  {fun grisp_connect_logger_bin:filter_out/2,
-                    {supervisor, report_progress}}}
-             ]
-           }}
+            % Enable our own default handler,
+            % which will receive all events from boot
+            {handler,
+                grisp_connect_log_handler,
+                grisp_connect_logger_bin,
+                #{formatter => {grisp_connect_logger_bin, #{}},
+                filter_default => log,
+                filters => [
+                    {disable_progress, {fun logger_filters:progress/2, stop}}
+                ]
+            }}
         ]}
     ]},
     {modules, []},